Incepción Ágil: ¿y entonces qué hacemos?

Esta actividad de la Incepción se puede realizar en grupos si tenemos gente con buena visión técnica como para ayudar en conceptualizar la solución a desarrollar.

Cuando digo "técnica" me refiero al punto de vista de lo que vamos a construir (si es un sistema, un arquitecto o líder técnico; si es de marketing o publicidad, un diseñador o experto en campañas; si es un proceso, alguien experto en ese área).

Si en la audiencia contamos con una sola persona con esas características, podemos realizar esta actividad todos juntos. La idea es que en grupo, y con la ayuda del experto, analizamos el tipo de solución a construir, a muy alto nivel.

Como la mayoría de los lectores de este blog están vinculados al software, tomemos un ejemplo de ese mundo, y supongamos que el equipo elabora un clásico diagrama de componentes, indicando que va a haber un servidor web, que hablará con una aplicación existente, que conecta con tales bases de datos e integra los servicios X, Y y Z...

Tal vez aparezcan detalles de seguridad, o se sugiera mover algo a una nube, o utilizar algún tipo de tecnología, y lo importante de exponerlo ante todos es que surjan dudas como:

• ¿Y eso funciona en un Iphone?
• No se si conviene conectar con Siebel... eso quiere decir que si el proyecto del CRM se demora, nosotros también
• Antes de poner esos datos en la nube, deberíamos consultar con legales ¿Podemos dejar eso en una base local y mover lo demás?
• Creo que en el proyecto ZYX ya resolvieron esa interconexión ¿podemos pedirles ayuda?

Como antes, no buscamos que este diagrama o visión sea definitiva. Queremos explicar algunos detalles de cómo sería el proyecto para que la gente de otras áreas, técnicas, de negocio o administrativas, vean de qué se trata y comenten cualquier problema o relación que no hayamos tenido en cuenta.

Incepción Ágil: dime con quién andas...

El siguiente paso en nuestra Incepción es trabajar sobre los diferentes involucrados en el proyecto, y su nivel de participación.

Para esto volvemos a dividir en grupos a la audiencia y dejamos que trabajen en establecer su propio mapa. Suelo usar círculos concéntricos y post-its, o pueden utilizar u vector u otra representación.

La idea es que cada grupo piense en los diferentes "stakeholders", ya sean individuos con nombre y apellido, roles, sectores o áreas de una organización, otras organizaciones, instituciones o dependencias gubernamentales.

De alguna manera lo que tratamos de manera es que tanto impacto tienen sobre el proyecto. Este mapa de influencias permitirá que pensemos cada cuánto tiempo el equipo de proyecto tendrá que tener contacto con estos actores, e incluso si necesita convocar a algunos de ellos para alguna actividad posterior a Incepción, pero también fundacional del proyecto, como un taller de Story Mapping (sobre lo que escribiré al terminar esta serie).

Como en los otros casos, al terminar revisamos los diferentes mapas y tratamos de consensuar el o los más representativos.

Recordemos que lo importante es participar activamente. Dejo otra foto de un taller donde estamos haciendo alguna de las actividades. Ese es el tipo de espacio que tratamos de crear (aunque no hace falta que haga frío).

Incepción Ágil: delimitando el alcance

La siguiente actividad en la Incepción es relativamente sencilla de realizar, pero suele generar más discusiones fundamentales, y tiene que ver con limitar ciertas decisiones respecto al alcance.

Como siempre, dividimos en grupos a los participantes, y en cada grupo generamos una lista de características ordenadas en tres grupos:

• Las cosas que definitivamente queremos dentro del alcance
• Las que estamos de acuerdo que quedan fuera
• Las cosas que no podemos decidir (al menos por ahora)

Como siempre, al presentar los resultados parciales de cada equipo aparecerán inconsistencias que resolver.

En general prefiero ir anotando los puntos de conflicto, en lugar de discutirlos en el momento, y seguir avanzando en la comparación. Una vez que comparamos todos los resultados, podemos recorrer la lista de los conflictos y tratar de zanjarlos.

Usualmente algunos de los puntos "indefinidos" para un grupo se logran definir por si o por no entre el resto, pero siempre pueden quedar algunos que específicamente quedarán a profundizar una vez que el proyecto arranque realmente. Lo bueno es que están identificados.

La lista resultante nos sirve de input para poder comenzar a construir el backlog cuando el proyecto comience, y la lista de las cosas que están fuera de alcance nos servirá a lo largo del proyecto como filtro de alerta cuando se quieran agregar cosas al backlog. Por supuesto, no implica un rechazo automático, pero si debería plantearse siempre una discusión al respecto.

Incepción Ágil: manos en la masa

Continuando con nuestra Incepción, en esta actividad vamos a ir más allá de la visión reducida del paso anterior, el Elevator Pitch, y comprobarlo usando una metáfora un poco más arriesgada, pero también mucho más divertida.

Usualmente para esta actividad consigo cajas en blanco, o cajas de un tamaño razonable (desde cereales hasta cajas de zapatos) y las cubro con papel blanco.

Nuevamente generamos grupos de trabajo (que idealmente pueden ir variando entre actividades para maximizar los cruces de opiniones) y le damos a cada uno una caja en blanco, marcadores y lápices de colores, papeles o post-its de colores, cintas, pegamento y otros materiales que sirvan para trabajar. Mis amigos Alan y Ariel suelen darle a la gente pegatinas o stickers con estrellas, animales, letras o cualquier otra cosa que puedan usar.

¿Cuál es el desafío?

Diseñar una caja que represente el proyecto que estamos encarando, como si fuese un producto de supermercado. La caja deberá ser atractiva, destacar las características principales sin apabullarnos, detallar en algún lado los componentes o características en más detalle, y más.

Entre otras cosas, usualmente este ejercicio hace que los equipos pongan un nombre al proyecto/producto, si no lo tiene.

Y es importante destacar que hacemos este ejercicio con portales web, sistemas de seguros, de salud, campañas de marketing, proyectos urbanos y montones de cosas que nada tienen que ver con un producto de consumo de masivo que se vende en caja. Estamos jugando con una metáfora.

¿Para que sirve, entonces? 

Desde mi punto de vista, como muchos de estos ejercicios, nos sacan de nuestra zona de comfort y nos exigen conceptualizar a un nivel diferente del que estamos acostumbrados, desatando más nuestra creatividad. A veces, la exageración aporta más visibilidad a ciertos temas y facilita la discusión.

Por otro lado, el hecho de trabajar en esta etapa temprana en una actividad muy manual, donde todos dibujan, recortan y pegan papeles, lleva a los grupos a un nivel de diversión y colaboración que cambia el tono de la reunión, reduciendo fronteras jerárquicas y de especialidades.

Al terminar sus cajas, como siempre dentro de un timebox (de 15 a 20 minutos), los equipos hacen una recorrida mirando las de los demás, y pueden votar por la más significativa, o dedicarle un rato a producir una con una versión conjunta.

Uno de los secretos de esta actividad es la cantidad de risas y entusiasmo que se genera. Es común que algunos grupos terminen trabajando en el suelo, o que se atrevan a utilizar el humor mucho más allá de otros espacios más formales.

Resultados a largo plazo

Aunque esta actividad parece tan inocente y lúdica, suele ser una de las que tiene enormes efectos a largo plazo.

Como facilitador, muchas veces no lo comento en el momento, pero lo verifico y aprovecho si tengo participación en el proyecto a largo plazo. Alguno efectos interesantes son:

• El nombre que inventan a veces para la caja se convierte en el nombre de código del proyecto. Así, por ejemplo, proyectos como el "nuevo servicio de atención para reclamos de siniestros", termina llamándose "Venecia" (por ejemplo).
• Una o varias de las cajas perduran y terminan colgadas o pegadas en el espacio del equipo. He escuchado comentarios de miembros del equipo explicándole a otra persona, con entusiasmo, por ejemplo: "¡y este dibujo de aquí lo hizo González, el Gerente de Canales!". Conexión del equipo con el negocio: altísima.
  
  
• Es común que los miembros de los equipos, al estar mezclados, hayan generado un lazo diferente en ese lapso tan breve, que les permite comunicarse entre ellos mucho más fácilmente durante el proyecto, porque comparten desde entonces un objetivo común que quedó plasmado en ensuciase juntos los dedos. 

 

Incepción Ágil: Visión de alto nivel

En el segundo paso de nuestra Incepción de Proyectos vamos a tratar de condensar la visión de cómo resolver el problema que nos convocó a muy alto nivel, pero entrando en algunos primeros detalles que podamos discutir abiertamente, y nos sirvan para seguir la conversación.

El "Elevator Pitch" es un término que viene del mundo del marketing de los años 60~70, y la idea es tener un argumento tan bien preparado y condensado, que pueda usarse para "vender" una idea a alguien al encontrarlo en el ascensor, aprovechando el escaso tiempo de un piso al otro.

Aunque es probable que en el caso de nuestro proyecto no necesitemos "vender" la idea más allá del grupo de la Incepción (o si, aún más tarde, cuando queremos enrolar a alguien más en el proyecto), utilizamos su estructura porque destaca una serie de elementos que nos resultan útiles discutir.

Nuevamente, es tarea del facilitador dividir a la audiencia en grupos de tres o cuatro personas, con papel y lápiz, para crear diferentes versiones del "Elevator Pitch" dentro de un time box de 5~10 minutos, que después presentaremos y discutiremos entre todos.

Una ayuda es mostrar un modelo posible, sobre todo para resaltar los componentes que buscamos incluir:

Para [ cliente | público ]
que tiene [ necesidad | oportunidad ]
[ nombre producto ] es un [ tipo de producto ]
que [ beneficio | razón de compra] 
A diferencia de [ principal competidor | alternativa ]
nuestro producto [ diferencial competitivo ]

Como se ve, todavía tiene muchos elementos de marketing, pero los elementos están ahí. Si se trata de un proyecto de desarrollo, podemos pensar quién es nuestra audiencia principal, su necesidad, que categoría de solución vamos a darle, cuál será el principal beneficio, cómo se diferencia de lo que se utiliza actualmente o alternativas que ya existan en el mercado, y así.

Suelo resaltar que no queremos listas de características.Es importante que podamos leer el resultado en 20 a 30 segundos. Los detalles vendrán después. Queremos por ahora sólo lo más importante.

Esta actividad finaliza con la discusión abierta y una reelaboración de la que obtenemos una sola frase consolidada, o unas pocas alternativas principales.

Dejo nuevamente un ejemplo pequeño del taller en al Tech Meetup de Montevideo.

Incepción Ágil: foco

La primer actividad que realizo en un taller de Incepción es una ronda en la cada uno se presenta y comenta para qué cree que está en el taller.

Como en general, el facilitador debería mantener el timebox, es decir, aclarar que cada uno tiene un tiempo acotado (en este caso podría ser uno o dos minutos por persona), y tratar de ser claro en lo que esperamos de cada participante, por ejemplo:

• Nuestro nombre y perfil (rol, área ó especialidad)
• Quién nos convocó
• Lo que creemos que podemos aportar en esta reunión

Al terminar la ronda, podemos hacer que cada uno escriba brevemente en un post-it cuál cree que es el objetivo principal de la Incepción: ¿qué problema queremos resolver?

Nuevamente ponemos un timebox de 2 a 3 minutos, y después pegamos todo en una hoja, agrupamos los que son iguales o similares, y discutimos brevemente las ideas que son muy disimiles.

El objetivo central es que lleguemos a tener claro entre todos el problema que queremos resolver, sin que nadie venga y "se lo comunique" al resto. Queremos que surjan las inconsistencias o diferencias de nivel de abstracción que haya entre los asistentes.

Otro tema importante: si entre la ronda y la definición final del foco descubrimos que alguno de los participantes probablemente no tenga mucho que aportar, ni le podamos aportar el resto, lo liberamos, agradeciéndole haber venido, y manteniendo un contacto por si descubriésemos que hay algún tema puntual para consultarle. Esto es algo que debe manejar el facilitador para que suceda sin conflictos. No queremos que nadie sienta que su participación "no tiene valor" per se, pero tampoco queremos que haya asistentes que no estén realmente involucrados con el foco de esta Incepción.

Incepción Ágil: ¿a los backlogs los trae la cigüeña?

Tanto en el caso de Scrum como XP u otros frameworks ágiles, nos basamos en una lista priorizada de items a implementar. El nombre más común para esta lista es el que se usa en Scrum, que es Product Backlog, o Backlog a secas.

Sacando de lado que los items del Backlog sean historias de usuario, casos de uso, o un híbrido de cualquier tipo, usualmente no está claramente detallado de dónde sale al menos la versión inicial que luego irá evolucionando a través de las iteraciones.

Por otro lado, siempre aparece la duda de cómo podemos hacer dentro del paradigma ágil para mantener la flexibilidad y postergar todo lo posible las decisiones duras respecto al producto, aprovechando a nuestro favor el aprendizaje continuo, pero sin perder de vista la visión general o el objetivo al que queremos llegar.

Una de las prácticas más populares en los últimos años en la comunidad ágil para generar esta visión común y comenzar a definir el backlog, es la Incepción Ágil, documentada inicialmente por Jonathan Rasmusson, alias Agile Warrior, en su libro The Agile Samurai y en su blog.

En este post inicio una serie en la que voy a intentar recorrer cada una de las 10 actividades que yo realizo al facilitar esta actividad, describiendo la manera en que yo (particularmente, y posiblemente a diferencia de otra gente) los oriento, y qué es lo que trato de generar.

¿Cuándo y cómo se realiza una Incepción Ágil?

Para empezar, el formato que recomiendo para esto es el de un taller colaborativo, y el foco es que estén presentes (y en un mismo lugar físico) todas las personas fuertemente involucradas en el problema a discutir (ya que tal vez no esté claro si se convertirá en un proyecto, varios, o nada). 

Lo ideal es lograr un buen nivel de compromiso desde los patrocinadores principales del proyecto potencial, o las personas que tienen responsabilidad sobre el problema que queremos resolver. Esto es importante para poder convocar también a la gente que conoce el problema (tal vez desde un punto más operativo), otros relacionados fuertemente (sectores o áreas relacionadas) o los que estarán potencialmente involucrados en la implementación o soporte (por ejemplo, gente de tecnología, desarrollo, diseño).

Por otro lado, suele ser clave el rol del facilitador del taller, que debe entender bien el formato general y las actividades individuales, poder moderar discusiones que se desborden, mantener el ritmo de la reunión, asistir las necesidades de los equipos, y otras tareas generales. En organizaciones donde ya hay gente que actúa como Scrum Master o Coach ágil, ellos suelen ser los más indicados. Pero también se puede contar con algún entusiasta que idealmente haya participado en una Incepción previa.

La duración también depende del nivel de importancia del proyecto/problema que vamos a tratar. Puede variar entre medio día y dos días completos.

En la práctica he facilitado Incepciones desde medio día con menos de 10 personas, hasta un día y medio con casi 20. No hay una regla muy específica a aplicar, y creo que cada organización y contexto debe encontrar su punto. Yo prefiero reservar más tiempo del esperado, y terminar antes, a quedarse "corto" y que los participantes se dispersen sin haber terminado.

El estilo de la reunión

Algo que para mi es fundamental es el estilo que le damos a este evento. Yo prefiero contar con un espacio abierto para poder moverse, algunas mesas para trabajar en grupos de 4 o 5 personas, y sobre todo muchas paredes para poder ir pegando resultados de las actividades. La mayor parte del tiempo lo que se va generando son  láminas con diferentes visiones del problema/proyecto, usando colores, tijeras, materiales varios, y en general un tipo entrañables livianos, poco formales, y que requieren trabajo manual.

Parte del secreto es que al trabajar con las manos y haciendo dibujos o armando cosas con las manos, generamos un ambiente en el que las jerarquías tienden a borrarse, generando mayor participación y una discusión más abierta, que al contrario de la formalidad excesiva, tiende a sacar a la luz mucho más fácil, pero sin tanto riesgo, montones de temas críticos.

Quedan debajo un par de fotos de un taller en el que practicamos esta técnica en el reciente Tech Meetup en Montevideo, para que tengan una idea del tipo de cosas que tenemos al terminar (teniendo en cuenta que en esta caso trabajamos sobre un proyecto ficticio, y en un tiempo acotado de 90 minutos).

Para los que quieran seguir la serie de artículos, todos los artículos están bajo el tag inception, o pueden utilizar esta guía:

1. ¿Para qué estamos acá?
2. Elevator Pitch
3. Vision Box
4. Qué si, qué no
5. La comunidad
6. La solución
7. Los miedos
8. Tamaño
9. Trade-Off
10. ¿Cuánto cuesta?

 

Ficciones y Realidades, aumentadas o virtuales (+ video)

En 1992, Neil Stephenson publicaba su novela “Snow Crash”. En la historia, parte del movimiento literario de esa época conocido como Cyberpunk, Stephenson imaginaba un entorno virtual al que los usuarios se conectaban y en el que adoptaban un personaje, o “avatar” con características particulares, como un alter ego virtual. Aunque hay algún antecedente del uso de la palabra “avatar” para un concepto similar, esta novela fue la que lo popularizó y trajo hasta nuestros días. No fue su única influencia: el creador del célebre Doom reconoce este libro como influencia directa, y algunas plataformas como Second Life o similares están sumamente basadas en esa obra.

La principal diferencia entre la manera de “entrar” en el multiverso de Snowcrash, al igual que en otras ficciones de esa época, es que la interfaz no era, como en las aplicaciones que usamos, a través de un teclado y un monitor convencional, sino que se imaginaban cascos, guantes y hasta trajes de realidad virtual, que brindaban una experiencia totalmente inmersiva y en primera persona.

 

Pasaron diez años y pico para que en 2003 Cory Doctorow publicara su primera novela, “Down and Out in the Magic Kingdom”, en que imaginaba nuestra sociedad adaptada al uso de dispositivos auxiliares incorporados a nuestro cuerpo, de modo que estuviésemos conectados permanentemente con nuestros amigos o grupos especiales de personas cuando querramos, y que nuestra visión se complementase con datos relevantes sobre las personas, lugares o situaciones que estamos presenciando, nuevamente, en una experiencia totalmente integrada. Cory es un gran defensor de las licencias abiertas y esta novela, como todo lo que hace, puede descargarse gratis de su sitio, sin alguien está interesado (yo la recomiendo especialmente).

Saltando otro poco más de diez años, la realidad aumentada ya es algo a lo que nos estamos acostumbrando, en pequeñas dosis, y tal vez con grandes espacios de mejora, pero ya todos conocemos o usamos aplicaciones que nos permiten que nuestro celular “reconozca” ciertos objetos o imagenes y nos de información adicional, o reconozca el tema que estamos escuchando en la radio y nos muestre la letra. Y obviamente tenemos al menos cerca muchísima información disponible sobre rutas, personas, el clima y demás en nuestros dispositivos. Y es el principio, porque ya están llegando desde relojes más inteligentes a dispositivos “usables” como Google Glass, que nos acercarán a esa experiencia de disponer los datos adicionales sin mirar a otro lado, sino como parte de nuestra visión general.

Y así como la realidad aumentada creció lentamente, la realidad virtual está regresando, después de unos 20 años en suspenso. De la mano de procesadores y sensores más rápidos, dispositivos como “Oculus Rift” están finalmente resolviendo los problemas que detuvieron el avance de esas experiencias virtuales inmersivas. Este producto, que está todavía en etapa de prototipo para desarrolladores de juegos, ya tiene muchisimo soporte de los principales productores de la industria, y está por salir al mercado, cuando haya cantidad de software generado, y cuando se haya pulido aún más para el mercado de consumo. Básicamente es una pantalla muy liviana, como la de una tablet, pero de alta resolución, montada en una especie de antifaz, y que produce dos mitades de la imagen, una para cada ojo, y tiene sensores de posición que hacen que al girar, subir o bajar la cabeza, la imagen virtual acompañe nuestros movimientos con una latencia tan baja que no podemos percibirla. Lo que falta por ahora es que no nos vemos a nosotros mismos, pero ya hay varios experimentos en conjunto con dispositivos como Razer Hydra (ver video debajo), una especie de evolución del controlador de la Wii, que podemos tener en las manos y puede generar parte de nuestra imagen en el mundo real. Y claro, hay otros controladores en marcha del estilo de los guantes virtuales que se imaginaban hace 20 años.

Como mencioné vez pasada hablando de nuevas interfaces, el desafío para nosotros es probar los SDK de estas nuevas herramientas e imaginar nuevos productos o servicios que podemos desarrollar integrándolas.

En resumen, las realidades aumentadas (complemento de nuestro mundo real) y las virtuales (que reemplazan nuestros sentidos con otro mundo) estan para quedarse. Es buen momento para volver a pensar en qué es la realidad, como el Maestro hizo a lo largo de 50 posts en su blog.

Aquí queda el video que muestra Razer Hydra en acción (menos de 3 minutos):

[Autobombo] Webinar de Arquitectura Ágil + Yoseki Coding Dojo semana que viene en RubyConf

Como avisé antes, el tag [autobombo] hace explícito que un post de este blog está referido a actividades en las que estoy directamente involucrado.

En este caso, quiero compartir el video (de ~50 minutos) del Webinar sobre Arquitectura Ágil que di anoche. 

 

Para los interesados en el tema, dejo links a la presentación original (muy similar a la del video) y al paper de hace unos años con el amigazo Diego Fontdevila en el Architecture Journal.

Para ver algunos de los comentarios durante el webinar, o posteriores, pueden mirar lo que quedó en Twitter bajo el hashtag #KleerArqAgil.

 

 

Por otro lado, si están interesados en la RubyConf Argentina, no se olviden que el próximo martes 26 de noviembre es el Ruby Fun Day, el evento anterior a la conferencia compuesto por talleres prácticos sobre diversos temas. Atención que este día es en la UP, no en Ciudad Cultural Konex como la conferencia.

En ese día de 15:30 a 17:30 voy a estar facilitando nuestro tradicional Yoseki Coding Dojo, edición Ruby. Si andan por ahí, pasen a saludar y avisen que leen este blog. :)

 

Novedades de Microsoft en direcciones interesantes (+ video)

Ayer hubo un evento de lanzamiento de Visual Studio 2013, donde Microsoft conato una serie de novedades. Algunas eran sabidas, dos en particular me llamaron la atención, porque me parece que son movimientos en la dirección correcta.

Finalmente se mostró el primer preview de la versión online de Visual Studio, que al parecer sólo se puede ver en videos por ahora, pero suena interesante. A pesar de estar bastante pegada a TFS online, una plataforma que no me resulta especialmente atractiva, mantiene y expande una actitud más abierta, con fuerte integración con Git, como se puede ver en el video que dejo debajo. Por otro lado, como verán, Node mantiene una presencia muy fuerte, con gran cantidad de ejemplos. La idea de que este entorno sea gratuito para grupos reducidos es importante.

Leí un par de notas periodísticas que mencionan esta iniciativa como una competencia directa de Microsoft a GitHub, que realmente me hicieron reír. Es cierto que algunos desarrolladores muy establecidos en el ecosistema Microsoft pueden preferir moverse en algún momento, pero no veo ninguna posibilidad de que algo de esto se plantee como una alternativa masiva. Al contrario, veo que son plataformas que pueden complementarse, y aunque no tengo chance de probarlo todavía, intuyo por las demos que tranquilamente se podría trabajar con esta IDE online desde un repositorio de GitHub. No veo ninguna dificultad técnica, y confío que el espíritu de apertura que intentan mantener desde este grupo de Microsoft no genere una barrera artificial.

Queda un video breve (~ 5 min) donde se muestra un proyecto Node, y cómo se utiliza el entorno, altamente integrado con TypeScript, que es otra estrategia interesante, sobre todo por lo poco intrusiva:

 

El otro gran anuncio es una asociación más directa con la gente de Xamarin, la empresa formada por los iniciadores del proyecto Mono, y todavía uno de los mayores grupos contribuyendo con él, que se dedica a permitir el desarrollo de aplicaciones nativas (no híbridas) en C# para iOS, Android, Windows Phone, OS X y otras plataformas (por extensión).

Lo interesante de esta asociación es que más allá de temas comerciales, tiene puntos técnicos muy importantes, logrando abrir más las puertas del ecosistema Microsoft / .NET hacia el exterior. Por ejemplo, las Portable Class Libraries (PCL) de .NET son ahora realmente abiertas y soportan el movimiento de librerías entre cualquier plataforma, facilitando muchísimo el intercambio también a nivel NuGet (el mecanismo de manejo de dependencias abierto del mundo .NET).

En total, esta noticia parece más de índole comercial, pero para mi el acercamiento al equipo de Xamarin y el reconocimiento del valor de llegar a estas plataformas fuera de su control son un blanqueo y una buena actitud que espero seguir viendo desde Microsoft hacia afuera.

Gigantes investigando: un vistazo al futuro

Creo que por acá todos saben que las empresas más grandes en la industria del software no paran de investigar, a ver quién gana en el próximo salto tecnológico, o quien se asegura un par de patentes que les de ventaja en el mercado los próximos años.

Más allá de que estemos de acuerdo o no con la política alrededor de la propiedad intelectual, es interesante echar una mirada a lo que están haciendo algunos de los principales centros de investigación de los gigantes de la industria. Gracias a la gente de Y Combinator, les dejo una serie de links a las páginas principales  sobre el tema:

• Microsoft Research y sus publicaciones
  Sus áreas de investigación cubren Comunicaciones y colaboración, Lingüistica computacional, Ciencias de la computación, Sistemas y Redes, Economía y Computación, Educación, Juegos, Gráficos y Multimedia, Hardware y Dispositivos, Salud y Bienestar, Interacción entre Computadoras y Humanos, Recuperación y Administración de Información, Aprendizaje Mecánico, Seguridad y Provacidad, Ciencias Sociales, Desarrollo de Software, Teoría y otras áreas temáticas.
   
• Research at Google y sus publicaciones
  Cubren Algoritmos y Teoría, Inteligencia Artificial y Aprendizaje Mecánico, Administración de Datos, Minería de Datos, Sistemas Distribuidos y Computación Paralela, Economía y Comercio Electrónico, Innovación en Educación, Ciencia General, Hardware y Arquitectura, Interacción entre Humanos y Computadoras y Visualización, Recuperación de Información y la Web, Percepción Mecánica, Traducción Mecánica, Sistemas Móviles, Procesamiento de Lenguaje Natural, Redes, Seguridad, Criptografía y Privacidad, Ingeniería de Software, Sistemas de Software y Procesamiento del Habla.
  
  
• IBM Research y sus publicaciones
  Uno de los pioneros en investigación de todo tipo, con más de 60 años en el tema y varios premios nobel a cuestas, cubren de todo, desde exploración y control espacial, genética y genómica, láseres industriales y quirúrgicos, salud, minería y por supuesto casi todas las áreas de software y hardware.
   
• Yahoo! Labs y sus publicaciones
  El menor de la serie, tal vez por ser la empresa que tiene hoy más problemas de crecimiento y subsistencia, de todas maneras se mantiene activa en áreas como Publicidad Computacional, Interacción entre Humanos y Computadoras, Medios, Aprendizaje Mecánico, Movilidad, Personalización, Investigación de Sistemas, y Búsqueda y Minería Web.

Les dejo un par de videos sobre los dos primeros, para darse una idea del estilo.

Research at Google (~3 min):

  

y un Tour por Microsoft Research (~10 min):

Imperdible: cócteles para programadores

Todos los años se festeja el Día del Programador, el día número 256 del año. Esta vez pasó el 13 de septiembre, y para festejarlo, un colega ruso publicó una serie de cócteles para programadores, publicada en GitHub, traducida a varios lenguajes, incluido el español, y con varias fotos muy buenas, algunas de las que reproduzco a continuación para abrirles el apetito (o la sed, en este caso).

Gracias a los amigos de Surculus Fructum por el dato.

Debajo, los cócteles para Ruby, Python y Assembler, respectivamente. En el post hay varios más, incluyendo las recetas. ¡Salud!

  

Agile Solo: Manejando el backlog personal

Continuando con la serie Agile Solo, hoy quería comentar algunas ideas para manejar el backlog de tareas y mejorar el nivel de compromiso de uno mismo hacia sus clientes o usuarios.

Una buena práctica para no dejarse tentar por la procrastinación es utilizar alguna herramienta para hacer público nuestro backlog. Como siempre, desde la agilidad le damos prioridad a la interacción entre las personas, por lo que prefiero concentrarme en cómo me comunico, y usar las herramientas más sencillas posibles (en particular me gusta Trello por que es liviano y su funcionalidad es mínima).

Lo importante para mi del backlog es tener donde volcar las clásicas tres columnas: pendiente, en marcha y terminado. Y lo bueno de tener una manera de hacerlo público es que podemos mostrar a las personas involucradas qué planificamos (por ejemplo, para la semana) y cómo vamos. Es posible que tengamos que unificar temas de varios clientes, y puede haber algunos relativamente confidenciales, para lo que prefiero usar nombres de código para los proyectos. De esta manera, cada cliente sabe el nombre de código, y puedo usarlo como “etiqueta” en mi backlog, sin divulgar identidades, preservando su confidencialidad. De la misma manera, no necesito poner detalles demasiado específicos de la tarea pendiente; alcanza con que ponga algo que mi cliente comprenda. Veamos un ejemplo:

Algunos tips sobre los nombre de código que me resultan útiles:

• No hacen falta para cosas no-confidenciales (en mi ejemplo, C&B para este blog, MUG, nombres de amigos)
• Conviene usar nombres que no signifiquen nada y que no tengan ninguna connotación. 
• Es bueno tener a mano una serie de muchos nombres disponibles. Yo elijo, por ejemplo, nombres astronómicos (estrellas, planetas o satélites) porque hay miles y usualmente no acarrean ningún significado especial. En otros casos utilicé nombres de ríos, pájaros, flores o plantas, frutas, etc. Google utiliza nombres de dulces para Android, Ubuntu animales más un adjetivo, etc.
• Lo importante es que el cliente reconozca SU proyecto (en el ejemplo, Fobos y Deimos son proyectos de clientes diferentes).

Obviamente exponer nuestro backlog plantea desafíos, pero yo creo que son sanos. Por ejemplo, el cliente de mi proyecto Fobos podría reclamarme prioridad sobre Deimos, aunque no sepa quien es. Eso nos obliga a ser transparentes, pero también a poder explicar racionalmente nuestra priorización, y el problema se termina si al final de cada iteración todos están conformes. También, aunque no hayan gran nivel de detalle en cada item del backlog, lo que hacemos para un proyecto puede inspirar ideas a otros clientes, y no está mal que esto pase.

Hay otras alternativas, por supuesto, como tener backlogs separados por cliente, donde cada uno vea su parte. En mi experiencia esto nos complica más de lo que nos ayuda, porque oculta la complejidad de nuestras actividades, y hace sentir a cada cliente que trabajamos solamente para él (lo que no está mal si es real).

Como siempre, hay cosas que dependen del nivel de madurez, pero en general yo prefiero que quien actúa de Product Owner en mi cliente tenga acceso a mi backlog y pueda poner todo lo que quiera. ¿Me arriesgo a que cambien prioridades? Si, pero prefiero siempre brindar más libertad y pedir responsabilidad que tratar de controlar. :)

Espero que algunas de estas ideas sirvan aunque sea para cuestionarlas y generar prácticas alternativas.

Nuevo sitio: Scrum Masters Community (+ video)

 

El amigo Tobias Mayer, pionero en dictar los talleres de Certified Scrum Master en Argentina, y un combatiente de la metodologías ágiles y Scrum en particular (incluso dando lucha desde adentro de la Scrum Alliance en su momento) lanzó recientemente un muy buen recurso para la comunidad de Scrum: un sitio web llamado scrummasters.community.

En el sitio se pueden encontrar libros, sitios y otros recursos recomendados por la comunidad de Scrum Masters en general, incluyendo algunos comentarios.

Es una especie de catálogo comunitario de recomendaciones, sencillo y útil.

Aprovecho el post para recomendar especialmente el último libro de Tobias, The People’s Scrum, que recopila los mejores artículos de Tobias en los últimos años, y no trata de explicar Scrum, sino que reflexiona sobre el espíritu, sobre el paradigma y las condiciones que estas prácticas crean, y a sus veces requieren.

Les dejo un video corto (~7 minutos; en inglés) de Tobias charlando en un evento sobre Scrum más allá de software.

Aprendiendo a programar Android en 12 clases gratuitas (+ video)

Por si alguno no se enteró, el equipo de JetBrains adaptó su excelente IDE para Java IntelliJ lanzando junto a Google una versión gratuita llamada Android Studio, que se encuentra en Preview, pero ya disponible para descarga.

Como esta gente no se queda quieta, además de lanzar la IDE, que es una alternativa más moderna y mejorada (al menos en mi opinión) a Eclipse, se asociaron también con el sitio de entrenamiento en línea Tuts+ para publicar una serie gratuita de entrenamiento sobre desarrollo en Android, presentada por el italianísimo Dino Esposito (el contenido está en inglese), una personalidad del mundo .NET pero también reconocido por su ductilidad para moverse entre plataformas, y sus cualidades como autor y entrenador.

La serie, llamada Android for the Busy Developer, compuesta por doce episodios, está basada en IntelliJ y no en Android Studio (no se bien por qué, pero para todo lo básico es lo mismo).

La serie completa cubre:

1. Introducción (~12m) 
2. Diseñador de Interfaces (~18m)
3. Interactividad mínima (~11m)
4. Ciclo de vida (~20m)
5. Más actividades (15m)
6. Vistas de Lista (~16m)
7. HTTP (~14m)
8. Almacenamiento (~15m)
9. Menúes (~16m)
10. Diálogos (~11m)
11. Preferencias (~15m)
12. Publicación (~6m)

Como pueden ver, son más de dos horas y media de entrenamiento, totalmente gratis, y más allá de que Dino muestre cómo se usa IntelliJ, los conceptos aplican al desarrollo Android utilizando la herramienta que uno prefiera (incluso si uno prefiere programar en C#, utilizando Xamarin Studio), porque hay mucho sobre la arquitectura y APIs básicas de la plataforma.

Les dejo el primer episodio (~12 minutos), en el que Dino explica cómo hacer el clásico Hello, World, para que vean más o menos el tono de la serie.

 

[Autobombo] Libro gratuito de "Introducción a los lenguajes de la web"

Atención: en este post hablo sobre un trabajo mío, porque se trata de un trabajo gratuito y espero que útil para algunos de los lectores. Para ser bien explícito en los casos en que mencione cosas que me involucran directamente, decidí usar un tag (en el título mismo del post) [Autobombo]. Para quienes no comprendan el término, es un argentinismo que usamos para usando alguien se hace propaganda a si mismo. Pueden quedarse tranquilo porque no soy tan productivo, así que no creo que ocurra muy a menudo. :)

Con mi compañero de ruta Juan Gabardini terminamos recientemente la versión final (al menos por ahora) de este librito que es, como dice el título, una mera introducción a HTTP, HTML y CSS.

El objetivo del libro es acercar a los conceptos más básicos a gente que se está acercando al desarrollo, o que tiene experiencia en otras áreas, como aplicaciones de escritorio o tecnologías anteriores.

El libro cubre temas como Internet (dominios, direcciones IP y puertos), HTTP (peticiones y respuestas; cookies) HTML5 (elementos, texto, enlaces y formularios), CSS, aplicaciones web mínimas (en PHP, Python y Flask, Ruby y Sinatra), y algo sobre URL semánticas.

Como explicamos en el arranque, no nos metemos en JavaScript, que es un tema mucho más grande, ni entramos en detalles muy profundos, pero tratamos de dejar punteros a otros recursos abiertos donde poder profundizar.

Todavía no lo agregamos a la página de Kleer donde pueden encontrar otros libros gratuitos, pero se viene en breve.

Espero que les resulte útil.

Libros gratuitos de programación

Revisando las estadísticas de este blog, veo que los posts más populares han sido históricamente los que se refieren a libros gratuitos, así que en un arranque de populismo, decidí agregar uno más.  :)   Al fin y al cabo, si son tan populares, espero que sea porque a los lectores les sirve contar con esos recursos.

Hay una lista ENORME de libros de programación gratuitos en inglés, que se actualiza periódicamente, y de manera colaborativa, y puede verse en:

• http://resrc.io/list/10/list-of-free-programming-books/

Quienes quieran colaborar, pueden hacerlo a través de este proyecto en GitHub.

Para quienes prefieren el español hay un recurso bueno y legal que tiene varios libros para leer directamente en línea, de temas genéricos como HTML, CSS, JS, Bootstrap y GIT.

• LibrosWeb

La era de las interfaces aéreas

Desde hace un tiempo vemos cómo las interfaces empiezan a alejarse del mouse, el teclado y últimamente las pantallas.

Mientras que todavía estamos tratando de optimizar al máximo las interfaces táctiles, seguimos teniendo montones de casos en los que lo ideal sería no tener que tocar la pantalla u otro dispositivo. Por ejemplo, en situaciones en las que estamos a cierta distancia de la computadora, o cuando tenemos las manos ocupadas en otras cosa, o sucias (cocinando, reparando un auto, o en medio de una cirugía, por ejemplo).

Primero fue Xbox y su accesorio Kinect, uno de los desarrollos más revolucionarios salidos de Microsoft últimamente, que aunque arrancó más orientado al mercado de juegos, pronto agregó una edición para Windows, con su correspondiente SDK, abriendo el dispositivo a lo que que nuestras mentes quieran hackear.

Kinect utiliza una combinación de sensores y un láser infrarrojo que brinda datos de posicionamiento de objetos en 3D. Básicamente, tiene cámaras HD normales e infrarrojas, con lo que consigue no solamente una imagen plana, sino información de distancia. A esto se le suma una serie de micrófonos y una buena cantidad de software.

El SDK para Windows tiene un par de maneras principales de programar: la primera es manipulando los datos en crudo, con el nivel de complejidad que implica, y la segunda es usando un API de más alto nivel que básicamente rastrea posiciones del esqueleto de hasta dos personas simultáneamente. De esta manera se puede programar a más alto nivel, siguiendo el posicionamiento de manos, cabeza, rodillas, etc. Kinect no es muy fuerte aún en reconocimiento de dedos individuales, ni está pensado inicialmente para estar a corta distancia.

 

Más recientemente se agregó a la partida Leap Motion, un dispositivo mínimo (ver foto), más chico que un teléfono convencional, tal vez un poco más alto. Se conecta por USB a una PC o Mac, y debe ubicarse entre nosotros y el teclado o el trackpad, básicamente bajo el área donde vamos a mover las manos.

La cajita contiene dos cámaras infrarrojas monocromáticas en conjunto con tres LEDs infrarrojos para lograr unos 300 cuadros por segundo a una resolución altísima, y es procesada por software propietario en el mismo dispositivo para proporcionar información de posicionamiento de los dedos muy detallada. Incluso permite detectar cosas como un lápiz en nuestra mano, y utilizarlo para dibujar sin necesidad de tocar la pantalla.

Leap Motion también provee un SDK con lo que pueden desarrollarse aplicaciones que exploten todo es potencial, que en principio es mucho mayor para aplicaciones de precisión, y como medio de interactuar con nuestra computadoras personales.

 

Y ahora llega Flutter, recientemente adquirido por Google, y disponible para OS X y Windows, con la particularidad de que no requiere ningún dispositivo externo. Solamente utiliza la cámara incorporada en las notebooks, y detecta (por ahora) unos pocos gestos, orientados en principio a controlar reproductores de media como iTunes, VLC y unos cuantos más que van sumándose, incluyendo ahora algunos sitios como Grooveshark o YouTube, utilizando una extensión de Chrome.

Los gestos que reconoce por ahora son mano abierta para detener o continuar, pulgar a un lado o a otro para ir al track siguiente o al anterior, pero prometen algunos más.

Lo que todavía no está anunciado es un SDK o API para programar sobre el análisis que ellos ya realizan sobre la imagen, pero ahora que Google ha tomado el control, no cuesta mucho pensar en que se integre como funcionalidad básica de Chrome, y porque no, se abra a más usos.

 

Finalmente, para mi lo que queda esperar es más sensores del estilo de Leap Motion integrados directamente en una próxima generación de notebooks, tabletas y teléfonos (hay algunos de Smasung que reconocen ya algunos gestos básicos sin tocar la pantalla) y sobre todo, la aparición de capas de software que realicen la mayor parte de las transformaciones matemáticas necesarias para que podamos luego programar a más alto nivel.

Agile Solo: prácticas ágiles para corazones solitarios

Espero que este post sea el primero de una serie (que quedará bajo el tag AgileSolo para poder rastrearla más fácil) que puede ir creciendo a lo largo del tiempo.

La idea surgió a partir de invitar a un amigo de toda la vida, que mantiene desde hace años su empresa de un sólo hombre con éxito, a uno de los talleres de Scrum que damos en Kleer.

Su experiencia fue muy buena, pero muchas veces durante el taller yo iba pensando cómo aplicar algunas de las prácticas que veíamos en un contexto como el de él, navegante solitario. Y como su situación no es única y yo mismo estuve ahí varios años (trabajando a veces solo y otras en equipos remotos y distribuidos) nació la idea de compartir aquí algunas ideas.

El mito del programador solitario

Lo primero que vale aclarar es que en realidad difícilmente trabajemos realmente solos. Gran parte de la estrategia a la que apunto en esta serie es que aunque nuestro equipo principal seamos nosotros mismos, podemos ampliarlo favoreciendo la colaboración con nuestros clientes, con terceros involucrados en nuestros proyectos, y con la comunidad misma.

Scrum en solitario

Por supuesto, no existe algo como "hacer Scrum al 100%". Como en todo marco de mejora continua, no existe un techo al que debamos alcanzar. Dicho esto, practicar Scrum en solitario es una solución de compromiso, distante del ideal, pero...

Repasemos rápidamente los roles de Scrum:

• Scrum Master
  Su responsabilidad es facilitar que el equipo de Scrum  (incluyendo al PO) alcance su máxima productividad, calidad y felicidad. En la práctica facilita reuniones, remueve impedimentos y usualmente lleva un backlog de mejoras surgidas de las retrospectivas.
   
• Product Owner
  Su responsabilidad es lograr que el equipo pueda desarrollar el mejor producto posible, lo que implica un fuerte foco en la prioridad de negocio, estar seguro que todo lo que se necesita está en condiciones de construirse, y lograr impulsar la entrega y puesta en producción lo más frecuentemente posible, para facilitar el aprendizaje conjunto con los usuarios, clientes y otros involucrados.
   
• Equipo de desarrollo
  Es el equipo multi-disciplinario que se encarga de construir el producto, involucrando diseño, desarrollo, pruebas, arquitectura, manejo de datos y servicios, etc. Scrum propone que el equipo cuente con toda la gente necesaria para construir el producto adecuadamente.

¿Cómo compensamos estos roles en un one-man-team?

En principio, la alternativa para el Scrum Master es sin duda, auto-organizarse. Es todo un desafío hacer retrospectivas con uno mismo, pero se puede apartar un cierto tiempo y poner en práctica, aunque sea de manera individual, algunas ideas clásicas de las retros de equipos, como buscar qué queremos seguir haciendo, qué queremos probar y qué debemos cambiar. 

Un tip para general alto del azar y la perspectiva diferente que aportan otras personas es recurrir a métodos como el I-Ching ó las tarjetas Oblique Strategies de Brian Eno. En ambos casos se trata de una selección de frases o estrategias que tomamos al azar y usualmente nos dan una perspectiva totalmente diferente, por ser cosas muy genéricas. Son un antídoto contra el bloqueo mental, más que nada. Para ambos casos existen muchas aplicaciones gratuitas, con lo que no cuesta nada probar.

Lo importante (al igual que en los equipos) es acostumbrarse a mantener un backlog de mejoras. Mi recomendación usual suele ser priorizar las cosas que queremos mejorar, y comprometerse únicamente a la primera de ellas durante el siguiente sprint.

En el caso del Producto Owner la opción ideal siempre es que sea un rol cubierto por una persona de nuestro cliente. Cuando trabajamos solos es más importante aún para poder separar mejor los criterios, pero como siempre, hasta que esa persona comprenda y ejecute bien ese rol, deberemos asistirla en la priorización y mantenimiento del backlog, en el empleo de historias de usuario, y en la planificación de entregas.

Respecto al Equipo de Desarrollo, es la parte que más tradicionalmente encaramos en solitario. En estos casos solemos ser multi-disciplinarios casi por naturaleza, porque todo debemos resolverlo solos, pero podemos además aplicar sobre todo muchas de las prácticas principales de XP, como TDD y ATDD, integración continua, y si somos algo esquizoides, hasta programación de a pares. :)

En realidad, algo que me sirvió personalmente para compensar los pares de un equipo es buscar oportunidades de trabajar regularmente de a pares con otros colegas, aprovechando los canales comunitarios, y la tecnología disponible hoy día para hacerlo de manera remota.

Pero ya es bastante por esta primer entrega. Espero que les sea útil, y si tienen preguntas o sugerencias, les pido las discutamos en Twitter.

 

Se viene RubyConf AR el 27 y 28 de noviembre (+ video)

La grandiosa mitad de conferencia de Ruby rio-platense (la otra mitad es la RubyConf UY, que se hace en Montevideo por marzo) ya tiene fecha y unos cuantos oradores anunciados.

Entre las grandes figuras está mi amigo y Maestro Angel "Java" López, con foto y todo en el sitio, lo que es poco frecuente.

Y por algún error administrativo, me han aprobado mi propuesta y estaré facilitando el clásico Yoseki Coding Dojo en el Ruby Fun Day que se realiza el 26 de octubre (un día antes) en la Universidad de Palermo.

La conferencia principal será en Ciudad Cultural Konex, como en el 2011.

Como siempre, RubyConf (tanto en Buenos Aies como en Montevideo) es un evento organizado con amor y pasión, que se nota en cada detalle, desde las camisetas hasta la atención permanente, el ambiente entre asistentes y oradores, las reuniones antes, durante y después del evento, y la magia permanente durante todos los días.

El contenido es muy variado, desde temas súper técnico a cuestiones meteorológicas y más de negocios, por lo que todos tienen algo interesante, pero los encuentros entre charlas son una parte enorme del espíritu de esta conferencia.

Dejo de regalo un video divertidísimo de la charla del amigo Jano Gonzalez, "¿Dónde están mi interfaces?", el año pasado:

TDD rocks! con el Maestro Angel "Java" López (+videos)

Desde hace un par de meses el Maestro comenzó a grabar unos Hangouts sobre TDD, mostrando ejemplos de algunos de sus proyectos reales, mientras implementa funcionalidades.

Los vídeos no están en español, sino en Anglish (pueden aprender algo de este dialecto en este post previo), pero si hacen click en su nombre en YouTube encontrarán otros que tiene grabados en español. Me pareció particularmente interesante esta serie porque sigue un hilo temático.

Recuerden que además de multitud de conocimientos compartidos en Twitter, el Maestro también publica un post diario (al menos) los 365 días del año, en alguno de sus blogs:

• Blog técnico en español
• Blog técnico en anglish
• Blog ecuménico en español (recomiendo su serie de 50 posts: "¿Qué es la realidad?") 

¡Que disfruten la serie!

Se viene Ágiles 2013, el mes próximo en Lima, Perú

Para los que no se enteraron, Ágiles 2013, la 6ta conferencia latinoamericana de metodologías ágiles llega de vuelta a Lima (donde se realizó en 2010), con grandes expectativas.

La cita es el 10, 11 y 12 de octubre en la Cámara de Comercio de Lima, y tendremos:

• Key Note latinoamericano: Gustavo Quiróz
• Key notes extranjeros: Janet Gregory y Jurgen Apello
• Invitados especiales: Mary y Tom Poppendieck (que nos acompañaron en la primer edición, en 2008 en Buenos Aires) y Brian Keller.
• Agenda
• Open Space
• Clínica de Coaches
• y una comunidad vibrante para conocerse, discutir y divertirse,

El registro ya está abierto, así que espero ver a muchos por allá. Pueden buscarme, claro, en el stand de Kleer.

Les dejo un saludo de toda la tropa del último Agile Open Medellín invitando al evento (¡sólo 25 segundos!):

¡Opa! ¿Y este framework?

El framework Opa para JavaScript es más que un framework. En realidad, es un lenguaje + una librería, pero con un objetivo bastante ambicioso: Opa intenta cubrir con mismo lenguaje el desarrollo del lado cliente, servidor y el acceso a base de datos.

Según la introducción del proyecto en su repositorio de GitHub (traduzco):

Opa es un framework avanzado para JavaScript, compuesto de dos partes:

• Un compilador para el lenguaje Opa, que presenta una sintaxis de estilo JavaScript pero con muchas mejoras;
• Una librería JavaScript, que se usa en tiempo de ejecución.

Siguiendo la tradición de recorrer "Raros lenguajes nuevos", lo que más me interesó de Opa es el lenguaje mismo, y ese objetivo ambicioso, así que veamos algunas características:

Opa es open source (la librería con licencia MIT y el compilador GPL 3) y se autodefine como un lenguaje "full stack" ya que cubre todas las capas, y promete soportar aplicaciones seguras y escalables.

Las aplicaciones terminan ejecutándose sobre Node.js y usan MongoDB para el manejo de datos.

Soporta nativamente HTML5 y CSS y trata de automatizar la comunicación cliente/servidor con Ajax/Comet, y brinda un modelo de programación orientado a eventos y no-bloqueante (básicamente, respeta el modelo JS, pero subiendo el grado de abstracción).

Una de las promesas más atractivas de Opa es que se puede programar sin pensar (a priori) en la distinción entre cliente y servidor. El compilador analiza y distribuye el código, haciéndose cargo de toda la comunicación. Posteriormente, sin embargo, uno puede optimizar algunas situaciones utilizando los modificadores client y server.

Veamos el clásico "Hola, Mundo" en Opa:

Server.start(
   Server.http,
   { title: "Hola, Mundo"
   , page: function() {<h1>¡Hola, Mundo!</h1> }
   }
)

El programa se corre (habiendo instalado el compilador y las herramientas, obviamente) con el comando: opa hola.opa -- y la aplicación puede navegarse en http://localhost:8080

Algo interesante de Opa es que a pesar de compilar a JS (algo ya recurrente) es un lenguaje de tipos estrictos, aunque no hace falta declararlos porque se utiliza inferencia. Sin embargo, el compilador informa de cualquier tipo de violación y es bastante inteligente al sugerir incluso las opciones para solucionarlas.

Veamos un ejemplo más, con acceso a datos. Este ejemplo de los tutoriales cuenta clics y los almacena en una tabla:

import stdlib.themes.bootstrap

database int /counter = 0;

function action(_) {
    /counter++;
    #msg = <div>Thank you, user number {/counter}!</div>
}

function page() {
    <h1 id="msg">Hello</h1>
    <a class="btn" onclick={action}>Click me</a>
}

Server.start(
    Server.http,
    { ~page, title: "Database Demo" }
)

Como puede notarse en el ejemplo de arriba, el HTML queda completamente embebido como parte del lenguaje, sin necesidad de usar comillas para los literales, que además soportan interpolación sencilla. 

Obviamente, como Opa está basado en Node, también es posible usarlo en Linux, FreeBSD, OS X y Windows, y estando disponibles todos los fuentes, es posible compilarlo en otras plataformas también.

También tiene instrucciones para desplegar fácilmente aplicaciones en plataformas como Heroku, Cloud Foundry y otras, y existen packs para varios editores como SublimeText, Emacs, Vim, Eclipse, GEdit y otros.

Esto es una brevísima introducción porque realmente hay mucho por investigar en este interesante lenguaje. Si alguien profundiza, me encantaría que me cuente. Lo mismo haré por mi lado.

Y casi me olvido: como pueden ver en la ilustración más arriba, hay un libro publicado por O'Reilly.

Charlemos de tecnología, ¿ta?

Arrancó un promisorio podcast de tecnología en español, de los amigos uruguayos PoTe y Cuervo, bastante conocidos en la comunidad Ruby rioplatense.

Más allá de Ruby, porque son inquietos como la mayoría de los que andan por este blog, se juntan cada tanto a hablar de tecnología, y grabar un podcast sobre un tema o dos, y prometen invitados.

No se pierdan Surculus Fructum, el podcast. Ahí en el sitio pueden suscribirse mediante feed o iTunes, bajar el audio en varios formatos o escucharlo en la página, pero les dejo el primer episodio acá nomás para que si quieren escuchen un ratito y me crean que está bueno.

Destacable, también aunque esperable de esta gente, el hecho de que el sitio es una pinturita de HTML5 y con un diseño muuuuy minimalista y prolijo.

A prestar orejas:

Se acerca Java 8

La próxima versión del JDK está cada vez más cerca, con fecha estimada de disponibilidad general en marzo de 2014.

Para los interesados, hay una versión preliminar disponible, y la buena gente de JetBrains ya tiene una versión preliminar de IntelliJ que lo soporta.

Algunas de las características principales de la nueva versión de Java serán:

Mejoras en las interfaces

Ahora pueden definir métodos estáticos, pero sobre todo, pueden incluir una implementación default.

Para mi, esto último es notable.

Interfaces funcionales y Lambdas

Las primeras definen un único método abstracto, y están pensadas para servir principalmente para definir funciones de primer orden.

Las lambdas pueden ser instancias en base a estas interfaces, o de manera independiente, y su sintáxis es la siguiente:

(int x, int y) -> { return x + y; }

o en su forma más simple, sin parámetros de entrada:

() -> x

Hay soporte para closures en las lambdas, con algunas limitaciones, pero en general el soporte parece bueno.

Más ideas funcionales en la librería estándar

Por ejermplo, algunas de estas interfaces definidas en java.util.function:

Function<T, R> para definir funciones de prier orden, Predicate<T> para definir predicados como filtros, Consumer<T> para invocar acciones, Supplier<T> para devolver tipos y otras.

También se agrega el paquete java.util.stream donde se habilita finalmente esta funcionalidad básica en la programación funcional, que permite utilizar enumerables o iteradores de cualquier tipo de manera contínua, es decir que pueden pasar de funcione en función de forma secuencia o paralela, sin detenerse.

Mayor soporte a concurrencia

Siguiendo con el tema general, hay muchas mejoras en el API de colecciones usando streams, predicados y muchas de las características anteriores, y muchos agregados específicos para administrar concurrencia, basándose en todo lo anterior y empujando más fuerte el uso de estructuras inmutables.

Reflection, anotaciones y un nuevo motor para JavaScript

Hay agregados importantes en los dos primeros, y Nashorn es el nombre de código del nuevo motor de JS, que reemplazará a Rhino. Lamentablemente parecen estar implementándolo sobre hotspot en lugar de utilizar V8 u otro motor moderno. Esto en principio debería ser mejor a nivel de la interoperabilidad con el resto de la JVM, pero me deja dudas sobre el esfuerzo de generar un motor eficiente en cuanto a la ejecución de JS.

JavaScript Jabber: hablando en JS

Post cortito hoy para compartir un podcast que vengo escuchando últimamente:

En este podcast semanal (en inglés), un grupo de programadores que programan en JS y otros lenguajes, se reúnen y charlan sobre un tema, en muchos casos con invitados como autores de librerías, frameworks, o miembros de equipos en organizaciones o proyectos interesantes.

Dejo aquí el último episodio (a hoy) con el autor de Grunt.js.

Episodio 74 - Grunt.js con Ben Alman

JavaScript - La compilación del futuro (+ video)

Hace 5 años escribí en este mismo blog un post llamado "JavaScript - a programación del futuro", en honor a aquel libro clásico del Maestro ("Java - La programación del futuro", de MP Ediciones). Básicamente, mi hipótesis en ese momento, mirando alrededor, era que JS iba a impactar cada vez más, al resolverse temas de incompatibilidades entre navegadores, mejorar las implementaciones y herramientas, y solidificarse el lenguaje del lado del servidor.

Cinco años después, por una vez en la vida, parece que no le había errado demasiado. JS explotó en librerías, frameworks y herramientas de todo tipo, Node lo impulsó mucho más allá de los navegadores, tanto a los servidores como a aplicaciones de escritorio, middleware, robótica y mucho más.

Ahora, sin embargo, viene el siguiente paso: si JS es el lenguaje que finalmente cumplió la promesa de correr en todos lados, es hora de pensarlo más y más como EL runtime. Brendan Eich, el creador original de JS dijo hace unos años algo como "JS is the x86 of the web", insinuando que podía convertirse en el "assembler" de la web. Muchos lo acusaron de exagerado, pero...

Desde hace tiempo, kripken (también conocido como Alon Zakai) un investigador de Mozilla, trabaja en EmScripten, un compilador de LLVM a JS. En resumen, toma bitcode de LLVM, generado con C/C++ y lo compila a JS. ¿Parece ridículo? No lo es tanto, considerando que de esa manera ese código puede ejecutarse en cualquier navegador moderno.

Parece una propuesta completamente de laboratorio, con pocas aplicaciones prácticas. Hasta que uno mira los proyectos que ya la están usando en el mundo real. Uno de los ejemplos más impresionantes es el motor de renderización 3D del juego Unreal, que se migró de C++ a JS en 4 días. El resultado puede verse en este video.

El tema no se termina ahí, en la compilación a JS. Porque no todo código en JS es el más optimizable. Y aquí es donde kripken y amigos comenzaron ASM.js, un subset de JS que si permite altísima optimización en todos los navegadores, como puede verse en su presentación.

Para que quede claro, todo esto se está logrando en este mismo momento, con los motores de JS de hoy, sin cambios importantes. Si la idea se expande, como ya está sucediendo, los motores pueden optimizar aún más este subset, utilizando técnicas de compilación existentes y probadas por años, logrando aún mayor performance.

¿Estaremos llegando al runtime final? Dejo como material para pensarlo este video de Eich en la JsConf de este año (~26 minutos). Que lo disfruten.

Nitrous: un entorno de desarrollo completo en la nube

Después de un año de silencio ¡vuelve Code & Beyond!

Hace aproximadamente un año cambié de trabajo y me sumé a Kleer, donde como socio tengo muchas de las responsabilidades acuciantes de cualquier start-up, lo que requirió dejar algunas actividades de lado. Específicamente, este blog no tiene sentido para mi sin una frecuencia importante, por lo que quedó congelado… hasta ahora. Espero que disfruten algunos de los aprendizajes que compartiré con ustedes en adelante, y como siempre, el feedback es bienvenido en @MartinSalias.

---

Estoy probando la beta pública de Nitrous.io, un servicio de "dev boxes" en la nube.

Básicamente, lo que nos brinda (partiendo de un servicio básico gratuito con 384 MB de RAM y 750 MB de storage) es una "caja" con Linux (la mía es un Ubuntu 12.04.1 LTS).

Lo bueno del servicio es que puede accederse de múltiples maneras:

• por SSH directo
• abriendo una terminal en el navegador
• utilizando una IDE en línea (ver botón en la imagen)
• a través de la aplicación para Mac (a las que se espera que se sumen otras para Linux y Windows). Esta aplicación genera una carpeta local con subcarpetas para cada "box" que uno tenga, y las mantiene sincronizadas (estilo DropBox). Además de eso, agrega un icono y menú en OS X que facilita llegar al sitio o la carpeta local, abrir una terminal vía SSH o la IDE en línea, controlar el port forwarding o la sincronización, etc.

Las "boxes" se pueden crear utilizando plantillas que incluyendo componentes pre-instalados para (por ahora) Ruby/Rails, Node.js, Python/Django y Go.

 

Personalmente, lo que más me atrajo es abrir la terminal desde el browser, jugar desde ahí, crear una carpeta para probar, usar vim para crear un ejemplo pequeño en Node,js (a pesar de haber creado mi box con la plantilla de Ruby, Node ya estaba ahí), correrlo desde la consola, ir a la URL de preview (agregándoe el puerto 3000) que elegí y ver que ya estaba funcionando.

 

La aplicación para Mac anda bien, pero la sincronización de archivos agrega una latencia que prefiero evitar. Siendo poco fanático de las IDE, tener la terminal me alcanza y sobra (es lo mismo que conectar por SSH, pero desde el browser de una).

 

La verdad es que el proyecto promete, y me gusta mucho la idea de usarlo para alguno de los entrenamientos que doy regularmente.

PragPub de septiembre: revista gratuita y en varios formatos

Comenté sobre PragPub hace un par de años, pero para quienes no estaban por ahí todavía, vuelvo a recomendarla.

Se trata de una revista publicada mensualmente por The Pragmatic Programmers, la editorial de Andy Hunt y Dave Thomas, autores, entre otros, de éste clásico libro que todo programador debería haber leído.

La revista en si tiene unas 60 páginas (en su edición PDF) y cubre temas generales (en inglés) de programación y sobre el perfil profesional de los desarrolladores de software. Se edita mensualmente y en formato HTML (para leer en el navegador), PDF, epub y mobi (estos últimos para lectores electrónicos como Sony Reader y Kindle, respectivamente).

 Los temas de este mes son:

• Thinking Functionally with Haskell, por Paul Callaghan. Una exploración al sistema de tipos de Haskel y sus consecuencias en la validación de aplicaciones.
• Tales from the Ops Side, por Michael Nygard. Aquí el author del libro "Release it!" cuenta algunas escenas comunes en un escenario de operaciones.
• US Visa: My First iPhone App, por Alexander Demin. Cuenta la experiencia de construir la primer aplicación para iOS, incluyendo código.
• Threads, por Michael Swaine. Es una nota donde el editor de la revista cuenta la historia de Chris Espinosa, miembro del equipo de desarrollo de Apple desde la primer etapa de la compañía.

Y como siempre incluye las seccione Up Front (la editorial), Choice Bits (el ranking de los libros más vendidos de la editorial), Calendar (conferencia, charlas interesantes en varias partes del mundo, y otros eventos) y Shady Illuminations (la columna de opinión de John Shade).

 

En el caso de la revista, que es gratuita, tal vez no llaman tanto la atención la variedad de formatos y el hecho de que los archivos estén libres de toda protección, pero es interesante que lo mismo sucede con los libros de la editorial, que publica muchos títulos de nicho como Deploying Rails, Programming Your Home, The Cucumber Book y otros que los programadores difícilmente consigamos en otro lado, con el agregado de que en general el nivel es muy bueno, tanto o más que en las principales editoriales técnicas.

Libros gratuitos sobre Python

A principios de este mes comenté sobre un sitio en GitHub con libros gratuitos de JavaScript, que en el ínterin creció de 11 a 25 títulos (cubriendo también más HTML5).

La misma gente de Revolunet (una compañía francesa de diseño web) amplió ahora la idea a una lista similar con libros gratuitos de Python.

Hay libros de nivel inicial, intermedio y avanzado, incluyendo varios iniciales para aprender a programar en general, basados en Python, que siempre me pareció una excelente opción de primer lenguaje, sobre todo para niños y adolescentes, porque es simple y directo en el arranque pero no tiene techo.

Los libros intermedios son en general para programadores Python que quieren entrar en detalles del lenguaje o frameworks, y los títulos avanzados son interesantes porque entran en temas complejos, basándose en Python para resolverlos, como Computer Vision, procesamiento de lenguaje natural, sistemas complejos, o probabilidad y estadística.

Casi todos los libros están en inglés, excepto (por ahora) un par en francés. 

También, varios de los libros son proyectos colaborativos y abiertos, algunos incluso publicados y actualizados como blogs, a lo largo de mucho tiempo (como en el caso de Python Module of the Week) con lo que quizá encuentren traducciones disponibles que a mi se me escaparon, o pueden colaborar en ese espacio.

Entre los libros hay dos que me gustan mucho, volviendo al tema de enseñar a chicos:

Snake Wrangling for Kids, justamente orientado a enseñar a programar a chicos, y que usa bastante los gráficos de tortuga provenientes del Logo, otro gran lenguaje. El libro es una guía de la que uno puede salirse, pero hay muchas ideas buenas. El libro está disponible para Python 3 o 2.7, y para Linux, OS X y Windows, con lo que incluso se puede reunir un grupo de jóvenes multi-plataforma (como mis dos hijas y yo).

Making Games with Python and PyGame es una buena continuación porque requiere un mínimo de conocimiento de programación y Python, pero rápidamente se mete en algo que los chicos amamos: programar juegos.

Espero que aprovechen todo este material, aprendan mucho, y sobre todo, enseñen nuestro arte a la próxima generación.

Libros gratuitos sobre Arquitectura de Aplicaciones Open Source

La arquitectura de software es un terreno interesantísimo que más allá de que uno pretenda o no ser Arquitecto como perfil profesional, es importante para todo desarrollador, porque tiene que ver con la estructura de lo que construimos y con cómo tomamos las decisiones respecto a ella. Como en el caso del diseño de un producto, no es algo que se pueda evitar, cuando uno no dedica tiempo a la arquitectura, el producto final tendrá muy probablemente una estructura deficiente o endeble, pero no dejará de tenerla.

De todas maneras, este es un terreno que siempre pareció de cierta sofisticación, y que por lo tanto no ha generado mucho material libre y gratuito, salvo últimamente, de la mano de sitios web como InfoQ ó High Scalability, que publican informes detallados o algunos libros breves.

En este caso se trata de un esfuerzo conjunto, coordinado por Amy Brown y Greg Wilson como editores, y una larga lista de colaboradores, que compila, en dos volúmenes, reseñas de la arquitectura de aplicaciones de código abierto, explicadas por expertos en el tema, a veces coautores o parte del equipo del proyecto. En algunos casos se cubren familias o ecosistemas de aplicaciones, en lugar de productos individuales.

Todo el material está disponible de manera gratuita en el sitio web, bajo licencia Creative Commons Attribution 3.0 Unported, pero para quienes prefieran leerlo en Kindle u otro dispositivo electrónico, está disponible una versión paga cuyos derechos se donan íntegramente a Anmesty International.

Los dos tomos están en inglés, y cubren unas 25 aplicaciones populares cada uno.

Algunos ejemplos del Volumen I son: Asterisk (la plataforma de telefonía), Audacity (el editor de audio), Eclipse, el file system distribuido de Hadoop, mecanismos de integración continua, el ecosistema LLVM, Mercurial, Python Packaging, Selenium WebDriver y otros.

Algunos ejemplos del Volumen II son: Arquitectura Web Escalable y Sistemas Distribuidos, Ingeniería de Actualizaciones de Firefox, el compilador Glasgow Haskell, Git, el Dynamic Language Runtime y la familia de lenguajes Iron (IronPython, IronRuby, etc), MediaWiki, Moodle, nginx, PyPy, Twisted, ZeroMQ y otros.

La cantidad de material es impresionante y los temas están muy bien cubiertos, a gran nivel de detalle técnico.

¿Podrá Ward hacerlo de nuevo? Conozcan el Smallest Federated Wiki (+videos)

Ward Cunningham es una especie de leyenda viviente. Es uno de los pioneros de los patrones de diseño, miembro prominente de la comunidad Smalltalk, colaborador de Kent Beck en la definición de Extreme Programming (XP), firmante del Manifiesto Ágil, co-inventor de las tarjetas CRC (clase-responsabilidad-colaboración) e inventor de FIT y fundamentalmente, la wiki.

Así es, Ward inventó muchas cosas que están dentro del ámbito de nuestra profesión, el desarrollo de software, pero la wiki, que fue pensada inicialmente para construir documentación de manera colaborativa entre desarrolladores, llegó mucho más allá, y es uno de los hitos que ha transformado nuestra cultura, a partir del impacto de Wikipedia, siendo en gran parte responsable de todo el movimiento crowdsourcing.

Pero Ward no se queda quieto y sigue permanentemente experimentando y buscando formas mejores de hacer las cosas. Su último proyecto vuelve sobre los pasos de la wiki, causalmente, y se llama Smallest Federated Wiki (la más pequeña wiki federada).

Como verán, en su página personal de GitHub hay una larga serie de videos explicando el concepto, que pone foco en hacer que la wiki sea aún más sencilla de editar, aprovechando capacidades de los navegadores modernos y HTML5 como drag & drop, uso de JSON como soporte, etc, para permitir una edición más fluida, pero también la "federación" de contenido. Esto significa que se puede tomar contenido de una wiki y ponerlo en otra, pero no es solamente una forma de réplica, sino más bien algo similar a los "forks" de GitHub, donde cada copia es libre de crecer de manera independiente, sin afectar a su fuente original, pero pudiendo contribuir cambios seleccionados, si la fuente los acepta.

La mejora manera de entender el modelo, que tiene un lado servidor que se encarga del almacenamiento de las páginas y la colaboración entre servidores similares, y un lado cliente, que permite editar y modificar el estado, y federar el contenido de manera visual.

La documentación para usuarios finales de cómo utilizar el lado cliente está disponible -por supuesto- como un wiki federado.

Por supuesto todo el código es abierto y está en GitHub. La implementación de referencia del servidor (hay algunas otras en marcha) está escrita en Ruby utilizando Sinatra, mientras que la parte cliente está escrita en CoffeeScript.

A continuación, el primero de los vídeos para despertar su curiosidad (en inglés; ~2 minutos). Recomiendo ver el resto de la serie, que sigue aumentando con el tiempo.

Próxima reunión de Ágiles@Buenos Aires

El grupo Ágiles Argentina anunció la próxima reunión mensual de Buenos Aires para el próximo miércoles 15 de agosto (la semana próxima) de 18:30 a 20:30.

Como siempre, la registración a este evento gratuito es a través de Meetup, y el evento es esta vez en el auditorio del MUG, Rivadavia 1479 1er Piso.

El tema de esta sesión se llama "¿Cómo escribirías tu código si debe funcionar al primer intento?", y estará facilitado por mi amigo y colega de Kleer, Carlos Peix.

Carlos describe su propuesta así:

Ya pocos discuten las ventajas de diseñar nuestro código basándonos en ejemplos (pruebas). TDD ha llegado a nuestra profesión para quedarse. También muchos de ustedes conocerán los coding dojos, ya sea por comentarios, ya sea por referencias.

En esta ocasión me gustaría invitarlos a un coding dojo en el cual intentaremos movernos fuera de la zona de confort para un desarrollador que utiliza TDD: diseñar y escribir nuestro código sin ejecutar un solo test. Para hacerlo más interesante, agregaremos otra condición: el código debe ejecutar correctamente en el primer intento.

No hay trampas, lo lograremos, aunque parezca difícil. Una vez que conozcamos el otro extremo de TDD, nuestro panorama cambiará, o al menos, el mio cambió.

Esta idea tomo forma mientras leia este post, lo que haremos es muy similar pero con la kata Wincofon, inventada con el gran @MartinSalias hace unos cuantos años. 

Como verán, soy un poco pig en esta sesión, aunque no podré asistir por otros compromisos. 

Si quieren ver a Carlos en acción, pueden ver este video con el que inauguramos la serie de programación de a pares en este blog, que espero retomar en breve.