Repositorio de Ruby movido de Subversion a Git

17/06/2019
Artículo original

Hoy, el repositorio canónico del lenguaje de programación Ruby se ha movido de Subversion a Git.

La interfaz web para el nuevo repositorio es https://git.ruby-lang.org, y es proveida por cgit. Podemos mantener el condensado (hash) del commit del contribuyente directamente en el repositorio de Ruby.

Política de desarrollo

  • No usamos ramas de corta duración (topic branches) en cgit.
  • El repositorio en GitHub seguirá siendo un espejo. No usamos la característica de “Mezclar solicitud de cambio (merge pull request)”.
  • Las ramas ruby_2_4, ruby_2_5, y ruby_2_6 seguirán usando SVN. No enviamos nada a esas ramas a cgit.
  • Comenzando con ruby_2_7, usaremos cgit para desarrollar ramas estables.
  • No usamos merge commits.

Agradecimientos especiales

  • k0kubun

    k0kubun desarrolló de manera agresiva herramientas para publicar y retro-portar flujos de trabajo y también actualizó el script hook para git.

  • naruse

    naruse actualizó los cambios en características de Ruby CI y de Redmine (bugs.ruby-lang.org).

  • mame

    mame creó el script para notificar contribuciones en slack.

Trabajo futuro

Aún debemos completar algunas tareas. Si encuentra alguna incidencia relacionada con la migración a Git, por favor reportela en https://bugs.ruby-lang.org/issues/14632.

Disfrutelo!

Publicado por hsbt el 2019-04-23
Traducción de vtamara

Publicado Ruby 2.7.0-preview1

17/06/2019
Artículo original

Nos complace anunciar la publiación de Ruby 2.7.0-preview1.

Es una versión previa que se publica para obtener retroalimentación sobre la versión final planeada para Diciembre. Introduce una serie de características nuevas y mejoras en desempeño, las más notables son:

  • Compactar en el Recolector de Basura (GC)
  • Reconocimiento de patrones
  • Mejora en REPL

Compactar en el recolector de basura (GC)

Esta versión introduce la posibilidad de compactar en el recolector de basura, que defragmenta un espacio de memoria fragmentado.

Algunos programas Ruby de múltiples hilos pueden causar fragmentación en la memoria, que conlleva a un alto uso de memoria y a que se degrade la velocidad.

El método GC.compact se introduce para compactar el montón (heap). Esta función compacta los objetos vivos que hay en el montón de manera que usen menos páginas, y el montón resulta más amigable con la técnica de administración de recursos compartidos “Copiar ante Escritura” (Copy on Write o CoW). #15626

Reconocimiento de Patrones [Experimental]

El reconocimiento de patrones, es una característica ampliamente usada en lenguajes de programación funcional, se introduce como característica experimental. #14912 Puede recorrer un objeto dado y asignar su valor si concuerda con un patrón.

json ='{
	"nombre": "Alice",
	"edad": 30,
	"hijos": [
		{
			"nombre": "Bob",
			"edad": 2
		}
	]
}'
case JSON.parse(json, symbolize_names: true)
in {nombre: "Alice", hijos: [{nombre: "Bob", edad: edad}]}
  p edad
end

Puede ver más detalles en Pattern matching - New feature in Ruby 2.7.

Mejora en REPL

irb, el ambiente interactivo incluido con Ruby (REPL; Read-Eval-Print-Loop; Bucle-Leer-Evaluar-Presentar), ahora soporta edición de múltiples líneas. Es potenciado por reline, la implementación en puro Ruby de readline. También provee integración con rdoc. En irb puede presentar el manual de referencia para una clase dada, para un modulo o para un método. #14683, #14787, #14918 Además, ahora se presentan con colores tanto el código fuente de su programa al iniciar una sesión IRB con binding.irb como los resultados de inspeccionar los objetos de las clases del núcleo de ruby.

Otras características notables

  • Un operador para referenciar un método, .:, se introduce como característica experimental. #12125, #13581

  • Como característica experimental se introducen paramétros numerados como párametros por omisión en bloques. #4475

  • Un rango sin inicio se introduce de forma experimental. Podría no ser tan útil como un rango sin terminación, pero es bueno para DSL. #14799

    ary[..3]  # identico a ary[0..3]
    rel.where(ventas: ..100)
    
  • Se añade Enumerable#tally. Que cuenta las ocurrencias de cada elemento.

    ["a", "b", "c", "b"].tally
    #=> {"a"=>1, "b"=>2, "c"=>1}
    

Mejoras en desempeño

  • JIT [Experimental]

    • El código compilado con JIT es recompilado a uno menos optimizado cuando los supuestos de la optimización dejan de ser válidos.

    • Un método se puede ejecutar en línea (method inlining o inserción en lugar de llamado) cuando un método se considera puro. Esta optimización aún es experimetnal y muchos métodos aún no se consideran puros.

    • El valor por omisión de --jit-min-calls cambió de 5 a 10,000

    • El valor por omisión de --jit-max-cache cambió de 1,000 a 100

Otros cambios notables desde la versión 2.6

  • Proc.new y proc sin bloque en un método llamado con un bloque produce una advertencia.

  • lambda sin un bloque en un método llamado con un bloque produce un error.

  • Actualizada la versión de Unicode y Emoji de 11.0.0 a 12.0.0. [Característica #15321]

  • Actualizada la versión de Unicode a 12.1.0, añadiendo soporte para U+32FF SQUARE ERA NAME REIWA. [Característica #15195]

  • Date.jisx0301, Date#jisx0301, y Date.parse de manera provisional y como extensión informal soportan la nueva era japonesa, hasta que se publique un nuevo estándar JIS X 0301. [Feature #15742]

  • Requiere compiladores que soporten C99 [Misc #15347]

Vea más detalles en el archivo NEWS o en la bitácora de cambios.

¡Estos cambios constan de 1727 archivos cambiados, 76022 inserciones(+), 60286 eliminaciones(-) desde Ruby 2.6.0!

¡Disfrute programando con Ruby 2.7!

Descargas

  • https://cache.ruby-lang.org/pub/ruby/2.7/ruby-2.7.0-preview1.tar.gz

    TAMAÑO:   16021286 bytes
    SHA1:   2fbecf42b03a9d4391b81de42caec7fa497747cf
    SHA256: c44500af4a4a0c78a0b4d891272523f28e21176cf9bc1cc108977c5f270eaec2
    SHA512: f731bc9002edd3a61a4955e4cc46a75b5ab687a19c7964f02d3b5b07423d2360d25d7be5df340e884ca9945e3954e68e5eb11b209b65b3a687c71a1abc24b91f
    
  • https://cache.ruby-lang.org/pub/ruby/2.7/ruby-2.7.0-preview1.zip

    TAMAÑO:   20283343 bytes
    SHA1:   7488346fa8e58203a38158752d03c8be6b1da65b
    SHA256: fdf25573e72e1769b51b8d541d0e1a894a5394dbfdf1b08215aa093079cca64c
    SHA512: b3b1f59dce94c242ef88a4e68381a4c3a6f90ba0af699083e5a1a00b0fb1dce580f057dad25571fe789ac9aa95aa6e9c071ebb330328dc822217ac9ea9fbeb3f
    
  • https://cache.ruby-lang.org/pub/ruby/2.7/ruby-2.7.0-preview1.tar.bz2

    TAMAÑO:   14038296 bytes
    SHA1:   f7e70cbc2604c53a9e818a2fc59cd0e2d6c859fa
    SHA256: d45b4a1712ec5c03a35e85e33bcb57c7426b856d35e4f04f7975ae3944d09952
    SHA512: a36b241fc1eccba121bb7c2cc5675b11609e0153e25a3a8961b67270c05414b1aa669ce5d4a5ebe4c6b2328ea2b8f8635fbba046b70de103320b3fdcb3d51248
    
  • https://cache.ruby-lang.org/pub/ruby/2.7/ruby-2.7.0-preview1.tar.xz

    TAMAÑO:   11442988 bytes
    SHA1:   45e467debc194847a9e3afefb20b11e6dc28ea31
    SHA256: 8c546df3345398b3edc9d0ab097846f033783d33762889fd0f3dc8bb465c3354
    SHA512: d416e90bfa3e49cc0675c4c13243c8ec319b7a0836add1bd16bd7662d09eaf46656d26e772ef3b097e10779896e643edd8a6e4f885147e3235257736adfdf3b5
    

¿Qué es Ruby?

Ruby fue desarrollado primero por Matz (Yukihiro Matsumoto) en 1993, y ahora es desarrollado como Código Abierto. Corre en múltiples plataformas y se usa en todo el mundo especialmente para desarrollo web.

Publicado por naruse el 2019-05-30
Traducción de vtamara

Cómo crear tu propia skill para Alexa paso a paso

17/06/2019
Artículo original

Cómo crear tu propia skill para Alexa paso a paso

Los asistentes de voz están cada vez más presentes en nuestras vidas. Ya no solo en nuestros móviles, sino que tenemos todo tipo de dispositivos como, por ejemplo, Google Home o Amazon Echo, ambos con distintas variantes.

Al igual que pasó con los dispositivos móviles y las interfaces táctiles, ahora se abre un nuevo mundo de posibilidades para los desarrolladores con las interfaces de voz. En este artículo nos vamos a centrar en el asistente de voz creado por Amazon: Alexa. Que incluye ya 5 dispositivos como Echo Dot, Echo, Echo Plus, Echo Spot y Echo Show.

En los últimos meses he estado aprendiendo sobre cómo crear una skill, así se llaman las aplicaciones en este asistente, y las distintas herramientas que tenemos para ello. Escribí una serie de posts que voy a usar como referencia aquí según vaya comentado cada paso.

¿Por dónde empiezo?

Lo primero es pensar en la skill que queremos crear. Mi consejo es ir a algo sencillo que no requiera de bases de datos o llamadas a APIs externas. De primeras siempre podemos construir algo que tenga la información en el propio código de server, ya sea con código estático, un fichero JSON o similar. Ese fue mi caso cuando decidí crear mi primera skill que permite consultar los estrenos de cine de un determinado periodo de tiempo. Lo importante es que nos centremos en aprender el paradigma de crear una skill.

Hay bastante documentación oficial y alguna que otra charla en español. Hice una pequeña recopilación en mi primer post de la serie. Para conocer cómo funciona Alexa en pocas palabras puedes ver el siguiente vídeo (inglés) de la cuenta oficial de Alexa Developers en YouTube.

Desarrollo de la skill

Una skill de Alexa no es diferente a cualquier aplicación que se hace hoy en día. Tiene una parte cliente y una parte servidora. La parte cliente es la responsable de definir el modelo de interacción (Interaction Model) con el usuario. Este modelo está compuesto de varias partes que veremos más adelante. Para la parte server vamos a usar AWS Lambda y el SDK que nos proporciona Alexa para Java. Aunque sea para Java nosotros vamos a ver su uso con Kotlin. Cualquier lenguaje de la JVM nos valdría.

Antes de ponernos manos a la obra necesitamos tener una cuenta de desarrollador de Amazon. La podemos hacer desde la web oficial de Alexa y nos permitirá acceder al conjunto de servicios que ofrece Amazon a desarrolladores. En nuestro caso, nos permitirá acceder tanto a la Alexa Developer Console como a los servicios AWS donde usaremos AWS Lambda.

La primera skill que desarrollé, que he tomado como base para los artículos, permite a un usuario preguntar por estrenos de cine indicando un periodo de tiempo. Como escenario básico podemos plantear la siguiente interacción:

Basic Scenario

Igualmente el usuario podría hacer usar la skill con una “one-shot invocation”. O podría indicar un periodo de tiempo para el cual no se conocen los estrenos:

One Shot

Y, como evolución, al principio no obligaba a indicar un periodo de tiempo pero luego lo cambié:

Slot

Creando el Interactor Model con la Alexa Developer Console

La Alexa Developer Console es el site principal a la hora de desarrollar una skill para Alexa. Nos va a permitir cubrir gran parte del ciclo de desarrollo, pruebas, distribución, certificación y analíticas.

Adc

A la hora de crear una skill nos pide: nombre, idioma del skill y de qué tipo es. Los tipos disponibles dependen del idioma por defecto que elijas. Para español vamos a crear un “custom skill” ya que nos permitirá tener todo el control sobre la experiencia del usuario y crear nuestro propio interactor model.

Una vez creado pasarás a una ventana con diferentes pestañas. La pestaña de “build” será la que te ofrece toda la funcionalidad necesaria para crear el interactor model. La definición de este modelo no es más que generar un fichero JSON con una estructura concreta. Tendremos acceso a ese fichero si queremos, por ejemplo, versionarlo o crear otra skill partiendo de un modelo ya existente.

Checklist

A modo de resumen, las partes del modelo son:

  • Nombre de invocación, el nombre que usará el usuario para invocar nuestro skill.
  • Intents, las acciones que un usuario va a poder hacer.
  • Utterances, son sentencias definidas a nivel de intent y sirven para lanzarlos.
  • Slots, son argumentos dentro de un utterance destinados a recoger información del usuario. Hay que asignarles un tipo al crearlos. Amazon ya ofrece algunos tipos predefinidos, pero podemos crear los nuestros propios.

El uso de slots en nuestro modelo va a depender del caso de uso. De los elementos anteriores son los únicos que no son obligatorios de definir ya que puede que no nos haga falta recopilar información del usuario. Como vimos en la sección anterior, mi skill lo fui evolucionando de tal forma que acabé definiendo un slot obligatorio con información sobre un periodo de tiempo determinado (esta semana, este mes, la próxima semana, etc).

Una vez hemos definido el modelo tenemos que construirlo. Esto nos va a permitir probarlo con el Utterance Profiler, una herramienta dentro de la consola que no requiere tener el server desplegado para ejercitar el modelo.

Up

Usando AWS Lambda y Kotlin para la parte server

Ya creada la parte front de la skill vamos a explicar el back. Como dijimos antes vamos a usar AWS Lambda lo cual nos permitirá una integración muy sencilla. No voy a entrar en detalles de conceptos serverless porque no es el propósito de este post. Dejo aquí el enlace al artículo que escribió Ricardo Borillo sobre el tema.

Lo único a comentar es que uséis la región de Irlanda porque no todas os dejarán configurar una Alexa Skill.

Awslc

Necesitamos crear una función en el panel de AWS Lambda y usaremos como runtime Java 8. Tendremos que hacer algún trámite adicional de config si no tenemos creado un rol previo para temas de permisos en AWS pero es sencillo. Os recomiendo también trabajar en base a versiones de la función que habéis creado. Os dará flexibilidad y control a la hora de ir desplegando distintas versiones de código contra vuestra skill.

Una vez creada la función tenemos que hacer la conexión con la skill. Para ellos tenemos que añadir el trigger de Alexa Skills Kit en nuestra función y añadir el skill id que podremos encontrar en la Alexa Developer Console. A continuación, tenemos que usar el ARN de nuestra función para indicarle al skill el endpoint que vamos a usar. De esta forma, la parte front y back pasan a conocerse la una a la otra.

Lambda

Para el código del back, aunque hayamos elegido el runtime de Java 8, decidí usar Kotlin. Al principio lo hice en Java, pero lo acabé migrando. Tengo todo publicado en un repo de GitHub y podrás ver commit por commit el proceso. Como base usamos el SDK que nos ofrece Alexa para así poder recibir las peticiones de la skill y enviar respuestas completas a todos los devices que la estén usando.

Hay dos tipos de clases básicas que tendremos que crear:

  • Tantos RequestHandler como necesitemos para manejar los intents que vengan del skill. Un mismo RequestHandler puede manejar más de un intent.
  • Un SkillStreamHandler que será la clase principal de nuestro backend. Aquí registraremos los handlers que hayamos creado previamente.

Veamos la estructura básica de un RequestHandler:


public class StopIntentHandler implements RequestHandler {

    @Override
    public boolean canHandle(HandlerInput input) {
        return input.matches(intentName("AMAZON.StopIntent"));
    }

    @Override
    public Optional handle(HandlerInput input) {
        String text = "Gracias por usar Estrenos de cine";
        return input.getResponseBuilder()
                .withSpeech(text)
                .withSimpleCard(CARD_TITLE, text)
                .withShouldEndSession(true)
                .build();
    }
}

El método canHandle se usa para chequear si el handler puede manejar la petición que llega. Aquí la lógica básica que se suele hacer es mirar el nombre del intent de la request.

El método handle es el encargado de recibir el input y construir la respuesta para el usuario a partir de su request. Es el método donde irá el código más interesante del handler. Aquí también procesaremos cualquier slot que necesite nuestra skill. En el caso del ejemplo me gustaría destacar tres cosas:

  • withSpeech, le estamos dando a la respuesta el texto que Alexa dirá de voz al usuario.
  • withSimpleCard, aquí construimos una salida para Alexa que será útil para dispositivos con pantalla, como la app del móvil.
  • withShouldEndSession, con esto le indicamos a Alexa que, una vez manejada la request, no esperamos otra interacción con el usuario y cerramos la sesión, es decir, el skill.

Una vez creados los RequestHandler que necesitemos pasamos a registrarlos en SkillStreamHandler:


public class UpcomingMoviesStreamHandler extends SkillStreamHandler {

    public static final String CARD_TITLE = "Estrenos de cine";

    public UpcomingMoviesStreamHandler() {
        super(getSkill());
    }

    private static Skill getSkill() {
        return Skills.standard()
                .addRequestHandlers(
                        new LaunchRequestHandler(),
                        new HelpIntentHandler(),
                        new CancelAndStopIntentHandler(),
                        new NewReleasesIntentHandler()
                ).build();
    }
}

Destacar que el orden de registro de los handlers afecta a la elección del adecuado para manejar una petición del usuario. El SDK irá validando los handlers en el order que fueron registrados y el primero que retorne true para el método canHandle será el elegido.

Ahora ya solo nos falta crear un artefacto para desplegar en nuestro lambda.

Cómo probar la skill manualmente con las herramientas de Amazon

Con la parte back lista podemos probar manualmente el funcionamiento de nuestra skill de varias formas:

  • Con el Utterance Profiler como decíamos al construir el modelo. Sin tener el back desplegado vamos a poder lanzar utterances verificando el intent y los valores de slots que acabaría enviando al lambda.
  • Con las herramientas de AWS Lambda podemos crear eventos que serán lanzados al back que hemos creado. De esta forma, podemos simular peticiones que llegarán desde Alexa. Amazon ya nos ofrece plantillas para crear esos eventos de pruebas y tenemos un sistema de logs integrados de AWS.
Test Event
Simulador

Distribución y certificación

Y ya estamos llegando al final del proceso. Al igual que las aplicaciones móviles, tenemos que publicar nuestra skill en una tienda on-line que tiene Amazon. Para llegar hasta ahí tenemos que cumplimentar toda la información de distribución de la skill y pasar un proceso de certificación previo que realiza Amazon.

Todo esto lo hacemos a través de la Alexa Developer Console:

  • Desde la pestaña de Distribution sólo tenemos que completar el formulario que nos pide Amazon. Es fácil y no hay mucho que explicar aquí, pero quería destacar un apartado: las frases de ejemplo. Lo que pongamos ahí influirá mucho en el proceso de certificación y en cómo los usuarios interactuarán con el skill la primera vez. Además, desde aquí podremos también habilitar el beta testing sin necesidad de publicarla.
Distribucion
  • Una vez hemos completado lo anterior podremos pasar a la Certification. Desde aquí podremos hacer un par de validaciones previas al envío de la skill a la certificación por Amazon. Las validaciones previas llevan poco tiempo y tendremos feedback en la propia Alexa Developer Console. La certificación definitiva lleva algo más de tiempo y te llegará el resultado por correo electrónico. Ya sea feedback para arreglar cosas o que tu skill ha pasado el proceso y será automáticamente publicada en la tienda.
Submission

Conclusiones

En este artículo hemos ido viendo todos los pasos necesarios para crear nuestra primera skill de Alexa:

  • El caso de uso a resolver, crear una skill que nos permitiera preguntar a Alexa por los estrenos de cine de un periodo de tiempo determinado. El usuario tenía que indicar ese periodo de forma obligatoria, por ejemplo, “esta semana”, “este mes”, “la próxima semana”, etc
  • A través de la Alexa Developer Console hemos creado el modelo de interacción, el front de la skill, para con el usuario. Ahí hemos identificado las distintas partes del modelo: nombre de invocación, intents, utterances y slots.
  • Para la parte back de la skill hemos usado AWS Lambda y Kotlin. En este paso hay algunas tareas de configuración imprescindibles para conectar el front con el back. Además hemos visto cómo usar el SDK que proporciona Alexa para Java. Y, para finalizar, hemos generado el artefacto que se acaba desplegando en AWS.
  • Una vez tenemos ambas partes de la skill terminadas hemos pasado a hacer pruebas manuales. Desde la Alexa Developer Console tenemos acceso a un simulador que nos dará información muy detallada de cada interacción.
  • Y el último paso, completar la información de distribución de la skill y mandarla al proceso de certificación de Amazon. Una vez pasemos ese proceso de forma exitosa tendremos nuestra primera skill de Alexa publicada.

Yo no tenía muchos conocimientos previos sobre este tema, ni lo que implicaba tanto un paradigma de interfaces de voz como AWS. Gracias a los recursos que otros comparten y una gran documentación oficial pude crear mi primera skill en poco tiempo y ganar algunos dispositivos Alexa gratis. Amazon suele sacar promociones para desarrolladores de skills cada cierto tiempo. Pongo una par de enlaces en la sección final de recursos.

He aprendido mucho durante el proceso, sobre todo dándome cuenta de los retos a la hora de usar una aplicación con la voz. Temas como los acentos al hablar, la forma particular de cada uno de decir ciertas palabras o lo rico del lenguaje para expresar la misma acción. Son dificultades a las que te vas a enfrentar al crear este tipo de aplicaciones. Tecnologías como Alexa, y todo lo que tiene detrás por parte de Amazon, hacen más fácil gestionar estos desarrollos pero aún queda mucho por hacer. Además, como se puede comprobar con este artículo, crear tu primera skill es un proceso de poca dificultad.

Te animo a profundizar en temas como conversaciones por turnos, es decir, crear verdaderos diálogos entre Alexa y el usuario. Así como dotar a una skill de la capacidad de mantener el contexto o dar respuestas progresivas porque tienes que hacer alguna operación costosa o asíncrona en el server. Y, una de las cosas que creo que más puede gustar, jugar con el lenguaje de marcado para el habla que tiene Alexa con el cual podrás decir cosas en distintos idiomas, dar entonaciones a las palabras, usar frases predefinidas, etc.

Recursos

Frameworks para desarrollo de aplicaciones móviles híbridas

14/06/2019
Artículo original

El desarrollo de aplicaciones móviles mediante tecnologías web ha revolucionado el mercado del desarrollo móvil. Esto es debido a que este tipo de tecnología permite aprovechar las mejores características del desarrollo nativo, además de toda la potencia y facilidades que ofrece la tecnología web.

La tecnología híbrida nació para reducir los costes, los tiempos y facilitar el aprendizaje y desarrollo de aplicaciones móviles, aportando también la posibilidad de crear webs con estos desarrollos. Por ello podríamos decir que este tipo de aplicaciones son totalmente multiplataforma (Móvil, Tablet, Ordenador, TV…). Con el desarrollo de un código único podemos generar aplicaciones para las plataformas deseadas. En el caso de móvil, para Android e iOS.

El desarrollo de aplicaciones híbridas tiene una curva de aprendizaje mucho más suave que el desarrollo nativo. Para desarrollos nativos se requiere tener conocimientos en lenguajes de programación como son Java / Kotlin / XML para Android, y Swift / Objective-C para iOS, además de las herramientas y particularidades específicas de cada plataforma. Ello supone mayores costes al tener que contar con personal específico para Android e iOS, un aumento en el tiempo de desarrollo y tener que coordinar el diseño de modo que se asemeje lo máximo posible en ambas plataformas.

Imagen CC0 por Caspar Camille Rubin en Unsplash

Dependiendo del proyecto habrá que valorar la creación de un desarrollo nativo o híbrido, así como el tipo de tecnologías y los recursos que requiere el proyecto. El desarrollo nativo aporta una integración completa con el sistema operativo y, en cuanto a potencia, suele ser más potente a costa de más costes, tiempo, posibles errores, etc.

Para el caso de aplicaciones híbridas, será necesario disponer de ciertos conocimientos más específicos de framework o frameworks que lo componen, y esto dependerá del lenguaje en el que esté basado (JavaScript, ECMAScript, TypeScript, Dart…), además de otros conocimientos en HTML5, CSS3 (en muchos casos junto a SASS), JavaScript, así como las herramientas de Front-End utilizadas (Webpack, npm, Gulp, herramientas de testing…).

Tras esta pequeña introducción genérica a algunas de las diferencias entre aplicaciones nativas y aplicaciones híbridas, vamos ahora a repasar brevemente los frameworks más famosos para desarrollo de aplicaciones móviles híbridas; los que tienen mayor apoyo y desarrollo por parte de la comunidad. La mayoría de estos frameworks de aplicaciones híbridas que indicamos utilizan por debajo Cordova o PhoneGap para generar las aplicaciones.

PhoneGap / Apache Cordova

PhoneGap, que pertenece a Adobe Systems, permite desarrollar aplicaciones híbridas mediante tecnología web HTML5, CSS3 y JavaScript. Utiliza una API que permite acceder a elementos de hardware del sistema como la cámara, almacenamiento, acelerómetro, etc. Permite integrarse con otros frameworks como por ejemplo jQuery Mobile, etc. Apache Cordova es la versión de código abierto de PhoneGap, la principal diferencia entre estos dos frameworks es que PhoneGap tiene acceso al servicio de compilación en la nube Adobe Creative Cloud permitiendo compilar la aplicación para el sistema operativo deseado e independiente del sistema operativo donde se desarrolle. Consulta este artículo para más información sobre sus similitudes y diferencias.

Al contrario que otros frameworks mencionados más abajo que se ocupan de la parte de la interfaz, PhoneGap/Apache Cordova se encarga de la integración dentro del sistema operativo móvil y de dar acceso a los servicios de éste. Así que probablemente lo usarás junto a alguno de estos frameworks, que en muchos casos sólo ofrecen la parte de la interfaz de usuario en HTML, CSS y JavaScript.

jQuery Mobile

JQuery mobile dispone de una larga experiencia en este mundo de aplicaciones híbridas. Únicamente integra el framework jQuery basado en JavaScript. Su curva de aprendizaje es muy baja, sobre todo si ya se dispone de conocimientos de jQuery y JavaScript. Se ha quedado un poco atrás en cuanto a potencia y diseño si lo comparamos con el resto de nuevos frameworks que hay en el mercado, pero igualmente jQuery Mobile puede utilizarse en paralelo con otros frameworks de diseño como son Bootstrap, Materialize, etc.

Siempre es una buena opción para un desarrollo de la interfaz de aplicaciones híbridas, pero seguramente será necesario utilizar otra serie de librerías o plugins para mejorar su diseño o funcionalidades, dado que no contiene un diseño pensado en los estándares de diseño de las actuales plataformas móviles.

Ionic

Es uno de los frameworks más famosos para el desarrollo de aplicaciones híbridas. En sus inicios Ionic utilizaba el framework AngujarJS y PhoneGap para la parte de integración con plataformas móviles. Sin embargo, en sus últimas versiones (actualmente su última versión es Ionic 4) ha ido incorporando nuevos frameworks Front-End con los que poder desarrollar. Actualmente permite su desarrollo con los más famosos: Angular, React, Vue.JS.

Ionic integra una capa de diseño con estilos css y recursos como iconos, etc. Estos estilos pueden ser adaptados a los estándares de diseño de las plataformas Android e iOS. Otra de sus muchas ventajas es que Ionic tiene su propio IDE de desarrollo que nos facilitará el diseño y programación de aplicaciones.

React Native

React Native es un framework para crear aplicaciones híbridas que está basado en JavaScript y en un conjunto de componentes del framework ReactJS. Actualmente también es uno de los más famosos, y cuenta con una gran comunidad de desarrollo. Forma parte de aplicaciones muy potentes y conocidas, como Facebook, Pinterest, Skype o Instagram.

En el año 2018 la empresa Airbnb se vio obligada a cancelar un proyecto que estuvo desarrollando durante 2 años con React Native debido a que este framework no se encuentra maduro para proyectos de gran envergadura por muchos problemas en sus actualizaciones de versiones, fallos de inconsistencia, etc.

A pesar de todos estos problemas, React Native es una buena elección ya que tiene un potente equipo de desarrollo detrás: un equipo dentro de Facebook. Ello aporta una garantía soporte y desarrollo a largo plazo. Además, cada mes se realizan revisiones de React Native corrigiendo errores o aportando nuevas funcionalidades y mejoras.

Framework 7

Framework 7 no es uno de los más conocidos, pero tiene la ventaja de que es completamente independiente y por lo tanto no tiene dependencias externas en frameworks como Angular o React. En su apartado de diseño se asemeja a Ionic, aportando un diseño ajustado a los estándares de diseño de Android e iOS dependiendo de la plataforma en la que se ejecute.

Este framework tiene una curva de aprendizaje más baja que React Native e Ionic gracias a que se pueden realizar aplicaciones híbridas utilizando simplemente HTML5, CSS3 y JavaScript. No obstante Framework 7 permite su desarrollo también con Vue.JS o React si nos interesa. Para la emulación y ejecución requiere la combinación con Cordova o PhoneGap.

NativeScript

NativeScript permite el desarrollo de aplicaciones nativas mediante JavaScript y TypeScript. También permite el desarrollo mediante el Framework Angular, y en su última versión se ha incorporado también la posibilidad de desarrollar mediante el Framework Vue.js. NativeScript genera aplicaciones verdaderamente nativas, utilizando las mismas APIS que tendrías disponibles desde Android Studio (entorno de desarrollo nativo para Android) y XCode (IDE de Apple para desarrollo nativo en iOS). Incluso permite el acceso a bibliotecas nativas de terceros, aportando así mayores capacidades respecto al rendimiento y capacidades de las aplicaciones. Su mayor inconveniente es que el desarrollo de las interfaces de usuario es más complejo (es XML, no HTML), así como las abstracciones necesarias para acceder al código nativo de manera independiente del sistema. Con NativeScript no necesitarás a PhoneGap/Apache Cordova.

Conclusión

La principal ventaja que aportan las aplicaciones híbridas es que permiten, con un mismo framework, crear una aplicación para las distintas plataformas móviles. Esto permite desarrollar un mismo código para ambas plataformas, cosa que en proyectos nativos no es posible debido a que cada plataforma tiene que ser desarrollada en su propio lenguaje y con sus propias herramientas. Por lo tanto los proyectos híbridos suponen costes menores y menor tiempo.

En realidad cualquiera de los mencionados es una buena elección. Sin embargo, aunque se domine HTML/CSS/JavaScript y algún framework Front-End, mi consejo sería que tuvieses también algunos conocimientos sobre cómo trabajan las aplicaciones nativas y sus lenguajes, ya que te vendrán bien a la hora de compilar las aplicaciones, realizar ciertas tareas como configurar el controlador de versiones o la información requerida por las plataformas de publicación (Play Store, App Store), realizar integraciones con servicios de terceros o hardware, o efectuar modificaciones más avanzadas.

Actualmente uno de los frameworks que se están abriendo mucho hueco es Vue.js, ya que facilita mucho el trabajo y dispone de una curva de aprendizaje baja si se conoce bien JavaScript y jQuery. Por lo tanto, si tengo que elegir, personalmente me decantaría por una tecnología de las anterioremente citadas que permita desarrollar con Vue.js, es decir: Ionic o Framework 7.

Expresiones regulares en JavaScript (y otros lenguajes): búsquedas anticipadas y retrasadas

07/06/2019
Artículo original

Como ya he dicho en muchas otras ocasiones, en mi opinión las expresiones regulares son una de las herramientas más potentes que puede aprender un programador, y no solo para programar ya que sirven también en muchos entornos y herramientas.

Hoy me voy a detener a explicar con detalle el funcionamiento de una característica potente e infrautilizada de las expresiones regulares y que muchos programadores no entienden bien por lo que he podido comprobar. Se trata de las búsquedas anticipadas (lookahead asssertions en inglés) y las búsquedas retrasadas (lookbehind asssertions en inglés), que colectivamente se suelen denominar "Búsquedas alrededor" (del inglés lookaround asssertions).

Nota: la traducción al español de asssertion sería "afirmación" o "aserción", pero en mi humilde opinión se entiende mucho mejor "búsqueda" en este contexto y es por eso que siempre he usado esta palabra en mis libros, artículos y cursos y por eso la verás usada aquí también así.

Vamos a ver en qué consisten y cómo funcionan.

Búsquedas anticipadas

Desde que se presentaron las expresiones regulares en JavaScript hace 20 años, en 1999, se soportaban ya las búsquedas anticipadas tanto positivas como negativas. Vamos a ver en qué consisten.

Búsquedas anticipadas positivas

Una búsqueda anticipada positiva se define mediante el uso de la expresión (?=...), siendo los puntos suspensivos el valor a buscar. Permiten localizar un patrón que vaya justo a continuación de otro, pero solamente captura al primero.

Por ejemplo, la expresión regular /Windows\s(?=7|8|10)/ coincide con el primer "Windows" en la frase "Windows 8 fue muy polémico, más incluso que Windows Vista", pero no coincide con el de "Windows Vista" del final de la frase. Solamente devuelve "Windows" como resultado de la búsqueda, obviando el "8". Este es su aspecto visual si la analizamos con RegExper:

Representación visual de la expresión regular con búsqueda anticipada

Si lo probamos en Regex101 con una frase como la anterior que haga mención a varias versiones de Windows, vemos que solamente captura la palabra "Windows " (con el espacio incluído) cuando va seguido de 7, 8 o 10, pero no en otros casos, que es justo lo que queremos:

Probando nuestra búsqueda anticipada

Otro detalle sutil pero importante a tener en cuenta es que estas búsquedas anticipadas no consumen caracteres, es decir, después de que se produce una coincidencia, la búsqueda de la siguiente coincidencia comienza inmediatamente después de la anterior, no después de los caracteres que componen la cadena de búsqueda anticipada. Un ejemplo tonto de esto para entenderlo... Si tenemos la expresión regular /[abcd](?=ab|cd)/ lo que quiere decir es que va a buscar cualquiera de las letras a, b, c o d que vayan seguidas de las dos letras ab o dos letras cd. O sea:

Visualización de la expresión regular

Si buscamos con esa expresión regular dentro de en la cadena "aabcd" esto es lo que se encuentra:

Se localizan la primera a y la b

Se localizan tanto la primera a como la b. El motivo es el explicado: la parte de la búsqueda anticipada no se cuenta para el avance de la búsqueda, reanudándose ésta a partir de la parte encontrada que vaya delante de los paréntesis. Así, en la primera coincidencia (que son las tres primeras letras aab), se reanuda la búsqueda no después de estas 3 letras, sino después de la primera de ellas (la a) que es la coincidencia que se captura. Por lo tanto puede encontrarse la segunda coincidencia bcd, que de otro modo no se encontraría.

Si te preguntas cómo hacer para que se haga la captura de la cadena completa, es decir, en este ejemplo tonto que se capture aab y no solo la a y por lo tanto se continúe a partir de estos tres caracteres, la expresión correcta sería: /[abcd](ab|cd)/:

La representación visual de la expresión anterior

que solo obtendría como resultado aab, pero ya no bcd puesto que seguiría buscando a partir del cuarto carácter puesto que captura todos. ¿Ves la diferencia con el anterior?

Suena lioso pero no lo es si te paras un poco a pensarlo y lo pruebas con las herramientas que te estoy referenciando.

Búsquedas anticipadas negativas

Las búsqueda anticipadas negativas funcionan de manera idéntica a las anteriores pero a la inversa. Es decir, en lugar de considerar las coincidencias consideran las no-coincidencias.

Se denotan con una expresión como esta: (?!...), o sea, con una admiración final en lugar de un igual, siendo los puntos suspensivos el modelo con el que no queremos coincidir.

Por ejemplo, la expresión regular /Windows\s(?!7|8|10)/ haría justo la búsqueda inversa a la que hicimos antes, evitando las menciones a Windows 7, 8 o 10:

Representación visual de la búsqueda anticipada negativa

Si ahora la ejecutamos para ver cóm actúa, veremos que localiza el "Windows " de "Windows Vista", pero no lo hace con ninguno de los otros:

Resultado de ejecutar la expresión regular

Al igual que las anteriores, la captura no incluye la expresión dentro del paréntesis, por eso es anticipada, con los mismos efectos que en el caso anterior.

Búsquedas retrasadas

Una de las novedades de ECMAScript 2018 o ES9, presentado en junio de 2018, fue la introducción de este tipo de búsqueda que antes no estaban soportadas.

Importante: en el momento de escribir esto solo están soportadas por Chrome 75 o posterior (incluyendo en móviles Android) y los navegadores que comparten su motor, es decir, Opera, las nuevas versiones de Edge y otros menos conocidos como Brave o Vivaldi. Firefox no le da soporte todavía (aunque están en ello) , ni tampoco Safari. Por lo tanto conocerlas está muy bien pero no conviene usarlas todavía en aplicaciones abiertas en Internet donde no controlemos los navegadores que se van a utilizar. Las anteriores, sin embargo, funcionan en todos los navegadores, incluso versiones muy antiguas de Internet Explorer.

Las búsquedas retrasadas son similares a las que acabamos de ver pero se colocan delante del patrón que queremos localizar, no detrás.

Se denotan con una expresión del tipo (?<=...) en el caso de las positivas y (?<!...) en el caso e las negativas. O sea, como las anteriores pero añaden un símbolo de menor delante del igual o de la admiración.

Por ejemplo, por poner un ejemplo "geek", supongamos que queremos localizar en una lista de nombres todos los apellidos de personas que se llamen "Steve", desechando los apellidos de otras personas de la lista. Esto es muy fácil de conseguir con una expresión de búsqueda retrasada positiva como esta: (?<=Steve )\w+ que se representaría visualmente así:

Representación visual de la búsqueda retrasada

Nota: por desgracia Regexper no soporta todavía las búsquedas retrasadas, así que en este caso he tenido que simular el gráfico a mano, pero esto sería lo que mostraría en caso de soportarlas.

Y si la ejecutamos en Regex101 con una lista veremos cómo identifica rápidamente todos los apellidos ilustres de los Steve que hemos metido en la lista (en este caso hay 2):

Resultados de la ejecución en una lista

Lo mismo se puede hacer a la inversa con una búsqueda retrasada negativa, de modo que en nuestro ejemplo localice todos los apellidos de la lista de gente que no se llame Steve. Lograr esto es un poco más complicado ya que ahora debemos indicar más condiciones o nos localizará cosas que no son apellidos, ya que si solo ponemos (?<!Steve )\w+, cualquier palabra que no lleve delante Steve nos valdrá, y eso incluye los propios nombres. Por lo tanto la expresión sería: (?<!Steve )\b\w+$ que nuevamente he simulado en Regexper para que se vea claro su significado:

Representación visual de la expresión regular

Se busca cualquier fragmento de texto que esté al final de una línea, que sea una palabra entera y que no esté precedida por "Steve ". Otra opción similar habría sido quitar el espacio de "Steve " y ponerlo en el patrón a buscar, así: (?<!Steve)\s\w+$ pero nos localizaría los apellidos con el espacio delante (podríamos obtener solo el apellido rodeándolo con un paréntesis para luego poder extraerlo como una subcaptura/subgrupo).

Bien, usando esta expresión podemos ver que localiza perfectamente los apellidos de los no llamados Steve:

Resultado de la ejecución

consiguiendo lo que esperábamos.

Nota: cabe destacar que tanto en el caso de las búsquedas anticipadas com en el de las retrasadas podemos usar varias seguidas, una tras otra, para combinar varias condiciones. NO es tan frecuente verlo pero funciona perfectamente.

En resumen

Las expresiones regulares son una herramienta súper-potente a la que deberíamos aprender a sacar partido a fondo. Si vamos más allá de lo básico pueden llegar a ser muy complejas y bastante crípticas, pero pueden ahorrarnos horas de trabajo en muchas tareas.

En esta ocasión hemos estudiado cómo funcionan las búsquedas adelantadas y retrasadas, de las que no todo el mundo tiene claro su funcionamiento, con algunos ejemplos prácticos. Aunque me he enfocado en JavaScript, en realidad todo lo explicado sirve para casi cualquier otro lenguaje de programación que soporte expresiones regulares, como Java, .NET/C#, Ruby, PHP... así que, como cualquier cosa que aprendas sobre expresiones regulares, te servirá igualmente en cualquier lenguaje o entorno.

¡Espero que te resulte útil!

Cómo hacer un sencillo slider con HTML y CSS (y sin tocar JavaScript)

06/06/2019
Artículo original

Probablemente ya sabes que, cuando el atributo href de un enlace consiste en una almohadilla o hash (#) seguida de una palabra, el navegador hará scroll hasta el elemento cuyo id coincida con dicha palabra. De hecho, esto ya lo vimos en un post anterior.

Esta técnica no sirve sólo para enlaces internos, sino que puedes apuntar con un enlace a un elemento concreto de una página externa para que, al hacer clic, el navegador no solo cargue la página, sino que haga scroll hasta donde quieras.

Por ejemplo, si haces clic en este enlace irás al final de la ficha de nuestro curso de maquetación responsive con HTML y CSS en nuestro catálogo.

Esto más o menos lo conoce todo el mundo que maneja HTML, pero lo que no todo el mundo sabe es que existe un pseudoelemento de CSS para identificar ese elemento al que estamos apuntando. Estamos hablando de :target

Gracias a esto podemos crear un slideshow, un carrusel, una galería de imágenes o simplemente una pequeña presentación sin necesidad de echar mano de JavaScript o jQuery.

El slider paso a paso

En primer lugar preparamos una lista de elementos que queremos mostrar. Dentro de cada <li> pondremos lo que queramos. Yo he puesto texto que forma un mensaje al ir viendo cada diapositiva, pero podrían ser imágenes, audios, vídeos...

<ul class="slider">
    <li id="slide1">En campusMVP</ li>
    <li id="slide2">encontrarás los mejores</ li>
    <li id="slide3">cursos online de programación</ li>
    <li id="slide4">y aprenderás de la mano</ li>
    <li id="slide5">de los mejores profesionales</ li>
 </ul>

Y por otro lado tenemos los enlaces que vamos a usar para mostrar el contenido:

<nav>
    <ul class="menu">
        <li><a href="#slide1">Diapositiva 1<//a></ li>
        <li><a href="#slide2">Diapositiva 2<//a></ li>
        <li><a href="#slide3">Diapositiva 3<//a></ li>
        <li><a href="#slide4">Diapositiva 4<//a></ li>
        <li><a href="#slide5">Diapositiva 5<//a></ li>
</ul>
</nav>

Tampoco tienen por qué ser enlaces de texto. Por ejemplo, si estamos creando una galería de imágenes, aquí podríamos poner los thumbnails (vamos, las imágenes en pequeñito).

El CSS de nuestra galería

Ahora pasamos a aplicarle algo de estilos a nuestra galería para que sea funcional.

Básicamente, lo que vamos a hacer es lo siguiente:

  • Posicionamos de forma absoluta los <li> dentro dentro del <ul> que tiene position:relative;. De esta forma se apilan todos en el mismo sitio por orden de llegada (debajo de todo estará el primero). Si no conoces esta técnica, échale un vistazo a este post sobre posicionamiento absoluto.
  • Todos los elementos <li> de nuestra lista se ocultan con opacidad 0
  • Mostramos el primer <li> dándole una opacidad igual a 1
  • Cada vez que se hace clic en un enlace que apunta a un elemento de nuestra lista, haremos que este elemento pase a tener opacidad 1 gracias a que lo podemos identificar con la pseudoclase :target.
  • Como el primer elemento queda abajo de todo, será tapado por los elementos que vamos haciendo visibles al hacer clic, a pesar de que es el único que siempre tiene opacity:1;

¡Manos a la obra! Para hacer todo esto nuestro CSS podría ser este:

ul, li {
    padding: 0;
    margin: 0;
    list-style: none inside;
}
ul.slider {
    position:relative; /*Necesitamos que el ul sea relativo*/
}
ul.slider li {
    opacity: 0; /*Ocultamos todos los <li>*/
    transition: opacity .5s;
    position: absolute; /*Posicionamos en absoluto los <li>*/
    left: 0px;
    top: 0px;
    margin:50px;
    padding:50px;
    border:2px solid red;
    background:#fff;
}
ul.slider li:first-child {
    opacity: 1; /*Mostramos el primer <li>*/
}
ul.slider li:target {
    opacity: 1; /*Mostramos el <li> al que apunta el enlace*/
}
nav {
    position:relative;
    top:200px;
    left:50px;
}

Y el resultado sería este otro, un poco espartano, pero funcional:

Ahora que ya lo tenemos funcionando, ya solo nos queda aplicarle más CSS con el diseño que queramos, para que sea más bonito.

Yo le he añadido este bloque de CSS:

body, html {
    padding: 0;
    margin: 0;
    width: 100vw;
    height: 100vh;
    overflow:hidden;
}

ul, li {
    box-sizing: border-box;
}

ul.slider {
    padding: 30px;
}

ul.slider li {
    width: 100vw;
    height: 100vh;
    margin: 0;
    padding: 0;
    border: 0;
    background-color: gray;
    opacity: 0; 
    transition: opacity .5s;
    padding-top: 30vh;
    font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
    font-weight: bold;
    font-size: calc( 1.5rem + 1vw );
    text-align: center;
}

#slide1 {
    background-color: #00324b;
    color: #fff;
}

#slide2 {
    background-color: #65bce8;
    color: #00324b;
}

#slide3 {
    background-color: #f90;
    color: #00324b;
}

#slide4 {
    background-color: #00324b;
    color: #65bce8;
}

#slide5 {
    background-color: #65bce8;
    color: #00324b;
}

nav {
    width: 100vw;
    position: absolute;
    top: auto;
    right: 0;
    bottom: 0;
    left: 0;
    background: #f1f2f3;
}

nav ul {
    display: flex;
    justify-content: space-around;
    flex-wrap: wrap;
}

nav ul li {
    display: flex;
    flex-grow: 1;
    flex-wrap: wrap;
    box-sizing: border:box;
}

nav a {
    font-size: calc( 1.2rem + 1vw );
    text-decoration: none;
    font-weight: bold;
    color: #00324b;
    font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
    line-height: 1.8;
    flex-grow: 1;
    text-align: center;
    border-top: 5px solid #00324b;
    border-right: 1px solid #00324b;
    flex-wrap: wrap;
    position: relative;
}

nav li:last-child a {
    border-right: 0;
}

nav a:hover {
    background-color: #00324b;
    color: #fff;
    border-top-color: #65bce8;
}

nav a:active {
    border-top-color: #f90;
    background: #f90;
    color: #00324b;
}

Así queda como una presentación que ocupa toda la ventana del navegador:

Pero no te limites solo a esto, porque puedes darle muchos usos: un portafolio, una pequeña galería de fotos o de productos, navegación por pestañas, diferentes apartados de una web de una sola página...

Puedes descargarte aquí el código de ejemplo.

Espero que este pequeño truco te haya sido útil. Recuerda que, si te quieres aprender bien las entrañas de la maquetación y el desarrollo web front end, tenemos una completísima colección de cursos online creados y tutorizados por profesionales de primer nivel para cubrir todas las necesidades, tanto las de aquel que empieza desde cero en el mundo web hasta las de el que necesita dominar las técnicas más avanzadas de JavaScript y ECMAscript.

Las nubes de Microsoft Azure y Oracle Cloud se unen para ir a por la de Amazon

05/06/2019
Artículo original

Las nubes de Microsoft Azure y Oracle Cloud se unen para ir a por la de Amazon

Microsoft y Oracle acaban de anunciar que están trabajando juntos para ofrecer interoperaibilidad de sus servicios. Los dos gigantes que hasta ahora competían en el negocio de las grandes infraestructuras empresariales en la nube, han decidido unir fuerzas y además ofrecerán nuevas capacidades para sus clientes cortesía de esta asociación.

Gracias a este acuerdo, Microsoft Azure y Oracle Cloud podrán interconectarse, y sus clientes podrán migrar y ejecutar cargas de trabajo empresariales de misión crítica en ambos servicios. Los clientes podrán ejecutar una parte de la carga de trabajo dentro de Azure y otra parte de carga de trabajo dentro de Oracle Cloud.

Ambas plataformas permitirán el uso sin problemas de herramienta de Azure como Analytics y AI junto a servicios de Oracle Cloud como Antunomous Database. La idea es ofrecer a los clientes un único punto de venta para todos los servicios y aplicaciones en la nube que necesiten para ejecutar su negocio.

La batalla de las nubes

Azure Vs Aws Blog

El negocio de la nube está ampliamente dominado por Amazon Web Services, que tiene casi el doble de cuota de mercado que Microsoft Azure, su competidor más cercano. Este acuerdo con Oracle sin duda los hará más competitivos frente a otros rivales como las nubes de Google, IBM o Alibaba, pero especialmente, contra Amazon.

Mientras veteranos de la industria como IMB y Oracle se han quedaron un poco atrás a pesar de llevar décadas de experiencia, Amazon con su plataforma en la nube que lanzó en 2006, se terminó convirtiendo en el ente dominante del mercado.

El crecimiento de esta industria es una de las que tiene mayor potencial actualmente, no por nada Microsoft ha venido apostando más fuerte por Azure que por cualquier otro de sus productos, y de hecho ha sido el causante de que se estén plantando actualmente como una de las empresas más valiosas de todo el mundo, logrando alcanzar incluso el billón de dólares de cotización en bolsa.

La alianza con Oracle les trae a su plataforma todo el conjunto de aplicaciones para ventas, servicios, marketing, recursos humanos, finanzas, cadena de suministro, fabricación e infraestructura de la empresa. Es un acuerdo estratégico para empujar a más clientes empresariales a migrar a la nube, y como explica Don Johnson, Vicepresidente ejecutivo de Oracle Cloud Infrastructure, "podrán hacerlo sin tener que rediseñar nada, y preservando las grandes inversiones que hayan realizado".

macOS Catalina utilizará zsh en lugar de bash como la shell por defecto

04/06/2019
Artículo original

macOS Catalina utilizará zsh en lugar de bash como la shell por defecto

El pasado 3 de junio durante la WWDC 2019, Apple anunció la próxima versión de su sistema operativo de escritorio macOS Catalina, una que llegará con varias novedades como la posibilidad de usar el iPad como segunda pantalla de tu Mac, y la división en tres apps de iTunes.

Sin embargo, entre las muchas cosas que no se comentan en la presentación, están novedades interesantes para los desarrolladores, y una bastante importante es el cambio de shell que sufrirá macOS próximamente: bash va de salida y a partir de Catalina, zsh será la shell por defecto.

Bash va de salida y también puedes cambiar a zsh en versiones anteriores de macOS

Empezando con la beta de macOS Catalina que ya está disponible a través del programa para desarrolladores de Apple, tu Mac usará zsh como la shell por defecto para iniciar sesión y también como shell interactiva. Aunque, también es posible utilizar zsh como la shell por defecto en versiones anteriores de macOS.

Con Catalina, todas las cuentas de usuarios recién creadas utilizarán Z shell por defecto. Si deseas cambiar la shell que usa tu sistema puede hacerlo desde el menú de Usuarios y grupos, y tras ingresar tus credenciales y desbloquear el candado para realizar cambios, podrás seleccionar entre zsh o bash en las opciones avanzadas:

Zsh Bash Macos

Aunque Apple no ha explicado por qué han decidido hacer este cambio, probablemente tiene que ver con finalmente implementar una shell más moderna a la versión de bash que usan actualmente, y también está el detalle de la licencia GPLv3 que usan las versiones más modernas de bash y a la que "Apple es alérgica".

Zsh es muy compatible con sh y bastante compatible con bash. Los comandos y la interacción en general de bash y zsh son casi idénticos, pero zsh incluye bastantes funciones útiles, tanto para usuarios avanzados como novatos que no están disponibles en bash, como por ejemplo, es mejor para autocompletar rutas de archivos y aplicaciones.

Más información | Apple

Por qué debes aprender más lenguajes de programación (incluso si no los vas a utilizar)

04/06/2019
Artículo original

Este artículo es una traducción del artículo "Learn more programming languages, even if you won't use them" de Thorsten Ball en su blog personal, con su permiso expreso. El énfasis en negrita es nuestro.

Imagina que te han entregado una tarea y eres libre de elegir el lenguaje de programación. La asignación implica todo tipo de manipulación de cadenas: leer cadenas, dividir cadenas, recortar, unir y ejecutar expresiones regulares sobre cadenas, todo en UTF-8 y, por supuesto, los emojis deben funcionar. ¿Qué lenguaje elegirías? ¿C? Oh, por favor no.

Otro trabajo, esta vez en una institución financiera. Necesitas realizar decenas de miles de cálculos concurrentes. Tener alto rendimiento es un requisito irrenunciable. ¿Deberías usar... Ruby? Venga. A continuación te cae: crear un script único que cambie el nombre de un grupo de archivos ... ¿lo escribirías en Java? ¿Hacer un descargador de datos de la web... en Python? Programar un controlador para un dispositivo médico con... ¿C#? ¿Swift? ¿Lua? ¿Ves por dónde voy?.

Los diferentes lenguajes de programación son buenos para algunas cosas y malos para otras. Cada uno hace ciertas cosas más fáciles y, a su vez, otras más difíciles. Dependiendo de lo que queramos hacer, podemos ahorrar mucho trabajo si elegimos el lenguaje de programación apropiado, el que hace que resolver el tipo de problema al cual nos enfrentamos sea más sencillo.

Ese es uno de los beneficios tangibles y sensatos de aprender varios lenguajes: añades otra herramienta a tu caja de herramientas y, cuando llegue el momento, podrás elegir la mejor. Pero yo iría un paso más allá.

Creo que es valioso aprender nuevos lenguajes de programación incluso si -aquí viene el golpe- nunca los sacas de la caja.

Imagen ornamental por Tim Mossholder en UnSplash

Las lenguas moldean nuestra forma de pensar*, y cada una lo hace de su propia forma. Eso es cierto también para los lenguajes de programación. Cada lenguaje contiene un modelo mental diferente, una perspectiva distinta sobre cómo pensar acerca de la computación y sobre cómo escribir programas.

Toma el lenguaje SQL, por ejemplo, y piensa cómo moldea tus pensamientos sobre el flujo y la forma de los datos en tu programa. Ahora considera cómo se vería en un lenguaje imperativo y orientado a objetos como Java, o en un lenguaje funcional como Haskell. O en C. Imagina cómo sería un servidor de juegos multijugador si lo programases en Python, en Haskell o en Erlang. O la transmisión y el procesamiento de terabytes de datos en C, en Go, en Clojure. O una interfaz de usuario en Tcl, en Lua, o en JavaScript.

Cada lenguaje de programación es una lente a través de la cual podemos ver el problema que intentamos resolver. A través de algunos de ellos el problema parece complicado, agotador. A través de otros, ni siquiera parece un problema en absoluto, apenas se ve la diferencia con cualquier otra cosa mundana que uno pueda hacer en este lenguaje.

Al aprender un nuevo lenguaje, incluso si lo dejas en tu caja de herramientas para toda la eternidad, obtienes una nueva perspectiva y una manera diferente de pensar en los problemas. Una vez que hayas implementado un servidor de juegos en Erlang, verás los servidores de juegos desde otra perspectiva. Después de haber procesado datos con Lisp, al aprender a pensar en los datos como un conjunto de listas que puedes moldear enviándolas a través de una serie de pequeñas funciones que se pueden componer para formar tuberías de funciones, verás como aparecen por todas partes sombras de este patrón. En cuanto hayas probado por primera vez la administración de la memoria en C, empezarás a apreciar lo que Python, Ruby y Go están haciendo por ti, mientras valoras el esfuerzo de su trabajo. Y si alguna vez has construido una interfaz de usuario en JavaScript con React.js, sabes que estás pensando en usar componentes para la UI, cambiando el modelo de manera fundamental.

Estas nuevas perspectivas, estas ideas y patrones, persisten, permanecen contigo, incluso si terminas por escoger otro lenguaje. Y eso es algo lo suficientemente poderoso como para seguir aprendiendo nuevos lenguajes, porque una de las mejores cosas que pueden sucederte cuando intentas resolver un problema es un cambio de perspectiva.

*Esto es lo que se conoce como relatividad lingüística o hipótesis de Sapir-Whorf. En el contexto de este artículo apoyo la tesis en cierto modo, pero debes saber que entre la comunidad científica su validez aún está muy abierta al debate. Lee este artículo para una introducción a los problemas con esta tesis.

Fundación Teléfonica presenta 42, una escuela gratuita para programadores, sin clases, ni horarios, ni profesores

03/06/2019
Artículo original

Fundación Teléfonica presenta 42, una escuela gratuita para programadores, sin clases, ni horarios, ni profesores

Fundación Telefónica acaba de anunciar 42 Madrid, un concepto de escuela que llega por primera vez a España y que es 100% gratuita, colaborativa, está disponible todo el año las 24 horas del día, y a la que cualquier persona mayor de 18 años puede inscribirse desde ya, sin necesidad de conocimientos previos ni titulaciones.

Lo más interesante de todo es quizás la promesa de inserción laboral para sus participantes, pues aseguran que en las escuelas de este tipo que ya están funcionando en otros países, hay casi dos ofertas de trabajo para cada estudiante.

A diferencia de una escuela tradicional, con 42 no hay libros, ni profesores, ni horarios. En su lugar, los estudiantes aprenden de forma colaborativa entre ellos, utilizando lo que llaman "evaluación peer-to-peer", es decir, cuando cualquier equipo termine un proyecto debe someterlo a la revisión de otros estudiantes.

La escuela, que abrirá sus puertas el 2 de septiembre, estará ubicada en el Distrito Teléfonica en Las Tablas, tendrá capacidad para 900 alumnos de manera simultánea y sus instalaciones estarán abiertas todo el día, todos los días, además dispondrán de espacios diáfanos para los ordenadores, un auditorio para 150 personas, salas de descanso y de ocio, cafetería, una sala de e-Sports y salas de trabajo para reuniones.

Un plan de estudios gamificado diseñado para durar unos tres años y medio

La idea es que los estudiantes busquen por sí mismos el conocimiento y lo compartan. Pero 42 sí tiene un plan de estudios, solo que está gamificado. Cada estudiante tiene un perl y un “nivel de experiencia”, y la finalización de un proyecto se recompensa con puntos que mejoran el nivel de experiencia. Los proyectos disponibles se presentan en forma de árbol, ofreciendo diferentes caminos hacia diferentes temas de informática y programación. Cuando se alcanza un nuevo nivel, se abren nuevas opciones del plan de estudios. Cuando no se supera un proyecto, se puede empezar de nuevo.

Aunque no hay horario, se espera que alcances metas específicas dentro de un tiempo asignado, es decir, hay una fecha límite para los proyectos, pero la gestión del tiempo hasta la misma, la decide cada alumno. El plan de estudios está diseñado para durar unos tres años y medio, pero eso depende de cada uno, puede durar más o menos.

El plan de estudios ofrece más de cien proyectos y actividades sobre programación y ciencias de la computación, incluyendo programación de Unix, programación en C, programación 3D, desarrollo web y más. Puedes revisar el curriculum entero para más detalles.

En total, actualmente hay más de 250 proyectos que se organizan en un árbol de programación con 21 niveles. Esos 21 niveles se dividen a su vez en dos círculos: materias comunes en torno a la programación como algoritmos, sistemas y gráficos por un lado, y por otro, contenidos específicos como inteligencia artificial, ciberseguridad, videojuegos o diseño gráfico, que va eligiendo cada alumno en función de sus intereses.

En Teléfonica dicen que esta metodología cuenta con una eficacia del 100% de inserción laboral entre los alumnos de de todos los países en donde está presente 42, y que durante su paso por la escuela, los alumnos reciben una media de ocho ofertas de empleo.

Cómo me inscribo

42 madrid

Solo tienes que acceder a la web de 42 Madrid y rellenar el formulario con tus datos básicos. Después deberás pasar dos pruebas online: un ejercicio de memoria de 10 minutos de duración y un test de lógica de 2 horas y media.

Los que superen esta fase podrán inscribirse hasta completar el aforo en las denominadas “piscinas”, que son las pruebas decisivas de acceso a 42. Aquí entrarán en contacto con el mundo de la programación a través de proyectos, audiovisuales y del conocimiento colectivo de los compañeros.

Esta fase de acceso es la más dura y la más exigente ya que los aspirantes deberán realizar un total de 13 proyectos y estarán una media de 12-14 horas diarias en la escuela durante un mes. La piscina se realizará en septiembre.

Más información | 42 Madrid - Preguntas Frecuentes

Página Anterior Página Siguiente