La llamada a ponencias para el Track de Investigación cierra hoy mismo (lamento no haber publicado esto antes) pero aún se pueden proponer Sesiones Técnicas hasta el 3 de octubre (queda casi un mes).
Por ahora el único invitado especial confirmado es Ian Piumarta, pero seguramente la lista de celebridades se incrementará a medida que se acerque la fecha, como siempre sucede.
Como regalo, les dejo la sesión del Maestro Angel “Java” López (a la sazón, oriundo de Quilmes) durante Smalltalks 2010. Como la conferencia es internacional, las sesiones se presentan en inglés, aunque en este caso se presentó en “Anglish”, como el orador explica al comienzo, antes de sumergirse de lleno en AJTalk, su intérprete del lenguaje Smalltalk sobre el CRL de .NET. Altamente recomendable:
La versión 1.0 de estas herramientas para programar Python en Visual Studio finalmente está disponible (gracias a @masaez por el aviso).
Este conjunto de herramientas es gratuito y de código abierto (bajo licencia Apache 2.0), y convierten a Visual Studio (que no es gratuito ni abierto) en una IDE muy completa para Python, soportando tanto CPython (la distribución estándar, no incluida en el paquete) como IronPython, la implementación de Python sobre el runtime de .NET.
Algunas de las características principales que hace atractivo el uso de estas herramientas es que agrega al editor básico con coloreo de sintaxis un buen soporte de Intellisense sobre miembros y firmas, navegación sobre el código como encontrar todas las referencias a un miembros, ir a su definición, o inspeccionar objetos. También soporta depuración local y remota, y perfilamiento para análisis de rendimiento.
Integra por supuesto una consola de comandos que puede usarse, al igual que el resto del entorno, también en entornos de clusters HPC y MPI, lo que permite trabajar interactivamente con infraestructura de procesamiento paralelo.
De hecho, sospecho que estos entornos son el motivo principal de la inversión de Microsoft en desarrollar estas herramientas, aún después de haber dejado el desarrollo de IronPython en manos de la comunidad. Python es uno de los lenguajes más utilizados (junto con C/C++) en el mercado de Computación de Alto Rendimiento (HPC), donde Microsoft está creciendo progresivamente a partir del lanzamiento hace unos años de Windows HPC Server. Sobre todo por bibliotecas clásicas en los mercados científicos, financieros e ingenieriles como NumPy o SciPy, y por el hecho de que programar resolución de problemas complejos en arquitecturas masivamente paralelas en C es bastante complejo, Python se ha establecido como una excelente opción.
Microsoft supo aprovechar el trabajo del equipo de IronPython para soportar su implementación en Visual Studio y la generalizo para muchas más áreas, lo que es en general una buena noticia, aún cuando lo cierto es que en la mayor parte de los contextos los programadores Python no solemos necesitar una IDE completa y preferimos la liviandad de un buen editor. En contextos complejos como HPC o uso de Interfaz de Paso de Mensajes (MPI) en ambientes distribuidos, es bueno al menos tener un buen soporte de depuración y algunas herramientas extra.
Debajo una pequeña muestra de las herramientas en acción:
Recientemente Scrum.org, la organización detrás de la difusión de la metodología, publicó la versión actualizada de la guía escrita originalmente por Jeff Sutherland y Ken Schwaber y revisada este año: Scrum Guide 2011.
En la misma página se encuentran disponible traducciones de la guía a muchos idiomas, incluyendo la versión en español (PDF, versión del 2010).
Para quienes no conocen más que lo anecdótico de Scrum, dejo un brevísimo resumen de este framework que se basa en tres pilares:
Transparencia
Inspección
Adaptación
El equipo de Scrum está compuesto por:
El Product Owner (PO, dueño del producto), que se ocupa de maximizar el valor del producto y el trabajo del equipo de desarrollo. Por eso es el responsable principal del Backlog de producto, y debe asegurarse que esta lista está siempre priorizada, de manera que nadie trabaje en lo que no es la máxima prioridad en cada momento.
El Equipo de Desarrollo es el grupo que se encarga de entregar incrementalmente un producto funcional al fin de cada Sprint (iteración). La guía agrega un poco más de detalle incluyendo la composición y tamaño.
El Scrum Master se encarga de que las reglas y principios de Scrum se mantengan y de que los bloqueos potenciales se eviten o eliminen cuanto antes. La guía detalla un poco más los servicios que el Scrum Master proporciona al PO, al Equipo de Desarrollo y a la Organización.
Los eventos de Scrum son:
El Sprint (o iteración) durante el que el compromiso asumido por el equipo y consensuado por el PO no debe cambiar, y se ejecuta manteniendo el orden de prioridad para el negocio, de manera de que al terminar el límite de tiempo impuesto (entre una semana y un mes) lo que quedó completo e incluido en el incremento de producto es siempre lo más importante. Dentro del Sprint se producen:
La planificación del Sprint, en el inicio, donde el Equipo y el PO acuerdan el compromiso para la iteración, tomando los ítems de máxima prioridad en el Backlog de Producto, en orden descendente, hasta donde el equipo estima que puede terminar dentro del límite de tiempo.
El Scrum Diario (o stand-up), donde el equipo se reúne (de pie, para evitar prolongar la reunión más de unos minutos) y cada miembro del equipo expone:
Qué terminó desde el último stand-up
Qué planifica terminar antes del próximo stand-up
Qué obstáculos puede llegar a tener (y que el Scrum Master deberá evitar que bloqueen al equipo)
El Sprint Review, en el que el equipo muestra el resultado del trabajo al PO y los interesados que éste considere apropiado para ayudarlo a continuar ajustando el Backlog de producto.
La retrospectiva en que el equipo reflexiona sobre la manera en que se desarrolló el trabajo, teniendo en cuenta relaciones, técnicas, herramientas y demás, y determina algunas medidas para mejorar en el siguiente Sprint.
Los artefactos de Scrum son muy pocos:
El Backlog de Producto, que el PO se encarga de construir y mantener priorizado en base al valor para el negocio a través del tiempo.
El Backlog del Sprint, que el Equipo y el PO determinan al comienzo de cada Sprint y cuyo seguimiento determina el nivel de avance dentro del Sprint.
El Incremento de producto es la entrega que el equipo realiza a final de cada Sprint, y que debe ser funcional desde el inicio, de manera que esté potencialmente en condiciones de usarse y agregar valor.
En la guía terminan volviendo a la importancia de la definición de cuándo una tarea está “terminada”, lo que debe convertirse en un contrato entre el Equipo, el PO y la Organización, de manera de ajustar las expectativas y evitar discusiones y problemas al respecto.
La guía amplía un poco este resumen, pero sólo tiene 17 páginas, incluyendo algunas con índice, historia, agradecimientos, etc. El framework es muy sencillo de describir, lo que no implica que sea fácil de implementar. Suele decirse que se parece en eso a un deporte: las reglas son sencillas, pero ser un buen jugador es típicamente un gran desafío y el secreto está en la práctica y la dedicación.
Video
Como final, dejo este video de una charla de Schwaber en el 2006 dentro de las oficinas de Google, que me parece que explica bien muchos de los principios, y aunque está en inglés, vale la pena escuchar esto desde uno de sus iniciadores.
El pasado 19 de julio el grupo Agiles.org de Buenos Aires realizó su ya tradicional reunión mensual, y en esta oportunidad el facilitador fue Fernando Parra (de MicroStrategy), quien contó un poco sobre los conceptos de emprendimiento alrededor del modelo Lean Startup, más basado en el foco en el diseño de producto y en el piloto inicial empujado por los mismos emprendedores más que el clásico modelo de buscar inversores para desarrollar una idea.
Este estilo de desarrollo de negocios está muy basado en una mezcla de métodos ágiles, software gratuito de código abierto, iteraciones cortas y extremo foco en el cliente final.
Y como personalmente no pude quedarme a la sesión, agrego las notas tomadas por mi amigo Ricardo Colusso:
La presentación se centró en emprendimientos de desarrollo de producto.
¿Porqué muchos emprendimientos fallan? Algunas razones: Optimismo infundado, foco 100% en el producto antes que pensar en quienes lo van a usar, resultado: el producto no encuentra mercado.
Proceso propuesto: Concepto de producto mínimo viable (MVP). Por ejemplo el primer teléfono de Apple que no permitía copiar y pegar.
Hablamos del Lean Canvas: http://leancanvas.com/ - Forma Lean de presentar información de startups. Puede bajarse gratis y usarlo/adaptarlo a lo que necesitemos (licencia Creative Commons)
La charla luego de la presentación fue por el lado de pensar cuan útil es un plan de negocios para un Llean Startup. Si quiero un subsidio de algún organismo oficial seguro que necesito hacer un plan de negocios, pero se habla de que probablemente me convenga no pedir plata y arreglarme inicialmente con lo que tenga. Se habla también sobre "burbujas" (como las punto com en 2001) que son vistas como oportunidades en el momento, pero que no tienen un sustento firme a nivel ganancias por cliente nuevo obtenido. Después estuvimos analizando en más detalle en que consiste el lean canvas, y encaramos un caso específico.
Nombres y fuentes de información mencionadas en la sesión:
Agradezco a Rick por las notas y les dejo la serie de videos (5 en total, cubriendo unos 80 minutos). Los últimos 10 minutos de la parte 5, aproximadamente, quedaron ocupados por el inicio de una actividad posterior que no tuve oportunidad de editar.
El MUG (Grupo de Usuarios Microsoft) realizará el 31 de agosto una jornada completa sobre Acceso a Datos (JAD 2011) en el Auditorio de UADE (Universidad Argentina de la Empresa), en Lima 717, Ciudad de Buenos Aires.
Para quienes no lo conocen, el MUG es un grupo de usuarios independiente, con más de 15 años de existencia, un millar de socios activos y muchos miles más de allegados a través sobre todo de sus cursos y jornadas (gratuitos o muy económicos) y sus listas de correo abiertas y gratuitas.
Aunque en el MUG la relación surge a partir de utilizar tecnologías de Microsoft, existe un espíritu muy abierto y permanentemente se realizan actividades más allá de esa plataforma, como actividades alrededor de Ruby, metodologías ágiles, manejo de proyectos, temas de negocios alrededor de las tecnologías de información y otros.
Esta Jornada de Acceso a Datos es casi un clásico del MUG que se enfoca en el tema recurrente en nuestra industria sobre el almacenamiento, búsqueda y explotación de datos, y cada vez más se extiende por fuera del campo de las bases de datos relacionales, como podrán ver a continuación, en la agenda del evento, en el que me toca dar la bienvenida.
El evento es gratuito, pero requiere registración previa porque las vacantes son limitadas. Pueden registrarse en el sitio del MUG (ignorando la pregunta sobre forma de pago).
El grupo ErlAr, que reune a usuarios de Erlang en Argentina, está intentando organizar para el año próximo una conferencia sobre lenguajes de programación, con foco principal en los lenguajes “no principales”. Esto quiere decir concentrarse en aquellos que no son los más populares en la industria local, como C/C++, Java, C# o Visual Basic, sino en los lenguajes que tienen pequeñas pero pujantes comunidades de seguidores, como Python, Ruby, Erlang (claro) y otros menos conocidos, algunos experimentales, incluso.
Esta idea no puede ser menos atractiva para mi, que soy un apasionado del tema, y para quienes disfruten de la serie “raros lenguajes nuevos” que mantengo en este blog.
El proyecto, que por ahora se llama Lang Day 2012, tiene las siguientes características, según el sitio borrador:
Objetivo
Brindar un evento de uno o dos días que permita a los asistentes obtener una idea sobre lenguajes de programación emergentes la cual le permita comparar:
Paradigma dominante del lenguaje
Tipado
Características principales
Fortalezas/Debilidades
Filosofía
Estado actual/Planes futuros
Estado de documentación/comunidad
Casos de éxito
etc. (agregar otros de ser necesario)
Formato
El evento intentara organizar las charlas de manera que los asistentes puedan asistir a las charlas introductorias de todos los lenguajes y luego decidan en cuales quieren profundizar.
Por esto el track de introducción será en una sola sala donde las charlas introductorias se realizaran una tras otra con una duración de 45 minutos.
Luego el track avanzado se realizará en 2 salas por lo cual el asistente deberá decidir en cuales lenguajes desea profundizar.
Por ultimo se realizará antes de la charla de cierre una serie de lightning talks con duración de 15 minutos que permita presentar de una manera mas superficial lenguajes menos conocidos o no tan maduros
Lenguajes Principales
Estos lenguajes son los que se desea presentar en profundidad en charla introductoria y avanzada de encontrarse presentadores:
Python
Ruby
Erlang
Scala
F#
Go
Haskell
quizas:
Clojure
Lenguajes Secundarios
Estos lenguajes son los que pueden presentarse en una lightning talk:
efene
LayerD
coffescript + node.js
etc
Calendario
Charla de apertura (de 30 a 60 minutos)
Charlas introductorias (sala única, 45 a 60 minutos)
Charlas avanzadas (salas múltiples, 45 a 60 minutos)
Lightning Talks (sala única) (entre 15 y 20 minutos cada una)
Charla de Cierre (entre 15 y 30 minutos)
Charla de apertura
La charla de apertura además de dar información sobre el evento debería informar sobre la utilidad de aprender nuevos lenguajes, y presentar una breve introducción a conceptos básicos que puedan ser utilizados durante las charlas como:
Tipado Estático, Dinámico, Progresivo, de pato, Fuerte vs Débil
Paradigma funcional, orientado a objetos y estructurado
El equipo del proyecto Mono, ahora formal y legalmente a cargo del equipo original reagrupado en Xamarin tras su salida de Novell, retoma el ritmo de entregas progresivas con su versión 2.10.3 que a pesar de ser una entrega “de mantenimiento” sorprende con estadísticas como:
Mientras tanto, para espíritus exploradores, accediendo al código fuente más actual desde el repositorio de Mono en GitHub, se puede comenzar a probar el soporte para C# 5.0, al menos sobre las características definidas y publicadas hasta ahora por Microsoft.
Como ya comenté antes, este año la conferencia latinoamericana de metodologías ágiles, Ágiles 2011 se realiza nuevamente en Buenos Aires, como en su primera edición del 2008.
Finalizada recientemente la llamada a ponencias, ya está disponible la primera versión del programa, donde pueden verse las sesiones aceptadas y distribuidas para los dos primeros días.
Pueden ver directamente las sesiones del día 11 de octubre y las del día 12 de octubre. El día 13 de octubre será dedicado exclusivamente al formato Open Space. El programa puede cambiar en cuanto a horarios, pero ya se pueden ver las propuestas aceptadas para los 7 tracks en paralelo, con contenidos en español, inglés y portugués.
El evento será del 11 al 13 de octubre en la Universidad de Palermo, Mario Bravo 1050 de la Ciudad de Buenos Aires. La registración está abierta desde hace tiempo y hasta el 31 de agosto hay un importante descuento.
Las figuras principales del evento serán los Keynote y Guest Speakers. Las keynotes (sesiones principales de los tres días) estarán a cargo de:
Siguiendo con sus planes de dominar el mundo, JavaScript tiene desde hace un tiempo un interesante motor construido en .NET que permite ser embebido en cualquier aplicación: Jint
El proyecto es de código abierto y fue iniciado por Sébastien Ros y colaboradores antes de ingresar a Microsoft, donde trabaja en el equipo del proyecto Orchard.
A diferencia de otros proyectos que intentan emitir código IL a partir de JavaScript, lo que es problemático por el problema de no poder descargar los ensamblados generados, o de otros proyectos basados en el Dynamic Language Runtime, Jint es un intérprete completo basado en ANTLR.
Jint permite utilizar JS como lenguaje para extender aplicaciones dinámicamente, algo que en .NET muchos hicimos previamente utilizando IronPython o IronRuby. Pero JavaScript es bastante más amplio en su uso, y esta clase de recursos siempre es muy valioso, sobre todo en este caso en que el soporte es muy completo, cubriendo la especificación completa de ECMAScript 3.0, y soportando en el último release muchos elementos del estándar 5.0.
Dejo el ejemplo más básico de uso desde C# (obviamente puede ser embebido en cualquier lenguaje .NET):
script= @" function square(x) { return x * x; };
return square(number); ";
var result = new JintEngine() .SetParameter("number", 3) .Run(script));
Addy Osmani es un reconocido diseñador y desarrollador web, experto en jQuery y colaborador del equipo de documentación de ese proyecto.
Recientemente Addy publicó el primer volumen de su libro en línea “Essential JavaScript Design Patterns For Beginners” (en inglés) que me parece un gran trabajo sobre patrones de diseño, cubriendo la definición conceptual de éstos, sus categorizaciones típicas, y finalmente recorre varios de ellos en JavaScript, no como una simple traslación de los patrones originales del GoF, sino apuntando a aquellos que muestran particularidades de JavaScript, y agregando otros muy específicos de este entorno.
Los patrones recorridos para JavaScript son: Creational, Constructor, Singleton, Module, Revealing Module, Observer, Prototype (que en JavaScript es central), Command, DRY, Façade, Factory, Mixin y Decorator.
Pero Addy no podía dejar de lado jQuery, por lo que cubre también los siguientes patrones de diseño en jQuery (verán algunos repetidos, porque analiza el patrón en el contexto de la biblioteca, no en sí mismo): Module, Lazy Initialisation, Composite, Wrapper, Façade, Observer, Iterator, Strategy, Proxy, Builder, Prototype, Flyweight.
Como valor agregado de este post, les dejo debajo esta presentación de Addy sobre trucos de rendimiento de jQuery:
La semana pasada el equipo de Google App Engine, la plataforma como servicio para ejecutar aplicaciones en la nube, anunció soporte para Go, uno de esos raros lenguajes nuevos, en este caso generado por el mismo Google, en lugar de surgir del ambiente académico o la comunidad de código abierto.
Esto hace que Go, diseñado para ser un lenguaje de sistema de un nivel apenas superior a C++, eliminando los típicos problemas de manejo de memoria y aportando características específicas para situaciones de alta concurrencia y paralelismo.
Go es un lenguaje “de llaves”, en la tradición familiar de C, pero sin necesidad de puntos y comas, al menos (las lleva pero el compilador se encarga de ponerlas solo). Veamos el clásico Hola, Mundo:
package main
import "fmt"
func main() { fmt.Println("Hello, 世界") }
Una de las características más interesantes de Go, y una de las que lo hace especialmente interesante para aplicaciones en la nube, es su implementación de co-rutinas, o funciones que pueden ejecutarse en paralelo, utilizando, casualmente, la sentencia “go”, pero además permite definir “canales” para mantener la comunicación entre procesos. Para los interesados que aún no lo hayan hecho, hay un buen tutorial de Go con muchos ejemplos.
Esta semana Novell / SUSE anunció que firmó un amplio acuerdo de colaboración con Xamarin, la compañía formada por el equipo que trabajaba para ellos en el desarrollo de estos productos, liderada técnicamente por el infatigable Miguel de Icaza y comercialmente por su socio de años, Nat Friedman.
El acuerdo incluye transferencia a perpetuidad a Xamarin de todos los derechos de propiedad intelectual de todos los productos de la familia Mono (incluyendo MonoTouch, Mono for Android and Mono for Visual Studio) y el control de todas las propiedades relativas al proyecto Mono, como MonoDevelop y la organización Mono en GitHub, y a cambio se compromete a brindar soporte a todos los clientes de SUSE utilizando la plataforma, lo que es un factor importante para grandes cuentas de Novell utilizando las ediciones Enterprise de Mono.
Básicamente, desde mi punto de vista, es una acuerdo de colaboración basado en el hecho de que Novell no puede hacer mucho con esos productos sin el equipo detrás, pero necesita seguir dando respaldo a muchos clientes que los están utilizando. Como menciona el gerente general de SUSE en el anuncio oficial, con este acuerdo ganan las tres partes: Novell, Xamarin y los clientes de ambos.
Inmediatamente después de sellado el trato, Xamarin puso nuevamente disponibles los productos en su tienda en línea, y en el anuncio de Miguel se entiende que gran parte del esfuerzo que Xamarin inició para construir estos productos desde cero (mientras negociaban este acuerdo) va a aplicarse directamente como correcciones e implementación de nuevas características en los productos existentes.
La noticia es muy buena también para la comunidad de código abierto, ya que aunque estos productos que permiten programar en C# en plataformas móviles son pagos, son también la fuente de financiamiento que la empresa necesita para continuar liderando el desarrollo del proyecto Mono, MonoDevelop y los demás componentes abiertos y gratuitos, que nunca se detuvieron.
Prueba de que todos estos cambios nunca afectaron demasiado a la comunidad es que este sábado 23, y hasta el lunes 25 se llevará a cabo la conferencia MonoSpace 2011, dedicada a la plataforma abierta, y alojada en el NERD Center de Microsoft en Boston. La conferencia se empezó a organizar antes de que el equipo de Mono fuera despedido de Novell, y la organización nunca se detuvo a pesar de todas las idas y vueltas que felizmente han concluido en este acuerdo que deja en completo control al equipo original.
Como ya vengo anunciando, del 11 al 13 de octubre llega Agiles 2011 a Buenos Aires. Esta será la cuarta edición de la conferencia latinoamericana, y la segunda en la capital argentina.
Algunas novedades de la organización es que se ha confirmado a Juan Gabardini como otro de los keynote speakers, cumpliendo con una antigua deuda en la comunidad de dar este espacio a los representantes más destacados de la comunidad local.
Juan en uno de los fundadores de la comunidad regional, reconocido especialista en el área de control de calidad de software con mucha experiencia también como mentor en torno a dinámica de grupos y metodologías, sin alejarse tampoco del código mismo. También es presidente del capítulo argentino de la IEEE Computer Society y docente en la Facultad de Ingeniería de la UBA.
Talleres extra
Aprovechando también la presencia local de los demás oradores internacionales, Juan está organizando también un taller con James Shore, titulado "The Art of Agile Planning". James es otro de los keynote speakers de Agiles 2011 y es el autor del libro "The Art of Agile Development", casualmente.
En este taller que James dictará (en inglés) los días 6 y 7 de octubre, la semana previa a la conferencia, James cubre los siguientes temas:
Organizar las reuniones diarias o stand-up
Crear y priorizar historias de usuarios, tareas y características mínimas con valor de mercado
Realizar compromisos confiables para la iteración y predecir la velocidad
Personalizar el horizonte a largo plazo según las necesidades de la organización
Calcular entregas predecibles para coordinarse con terceros
Adaptar planes para crear y aprovechar oportunidades
Esta es una actividad arancelada, por tratarse de un taller intensivo de dos días completos, y se llevará a cabo en el auditorio del Grupo de Usuarios Microsoft ().
Ayer Heroku, la plataforma para despliegue de aplicaciones en la nube (adquirida por SalesForce.com a fines del año pasado), anunció que Matz, el creador de Ruby, se sumó a su equipo como Arquitecto Jefe.
Esta es una gran noticia no solamente para la comunidad Ruby, sino para la industria en general, porque une más aún equipos innovadores y de una influencia muy positiva para toda la comunidad.
Por un lado, Matz es una persona inquieta y perseverante, que a mediados de los noventa decidió crear un lenguaje que hiciese feliz a los programadores, no a los compiladores, y a lo largo de los años mantuvo un gran liderazgo alrededor de una comunidad sumamente colaborativa que aportó grandes ideas al campo de los lenguajes y ecosistemas, y que incluso con la llegada de los "niños rebeldes" de Ruby on Rails, que trajeron una perspectiva muchas veces extrema y criticada, siguen llamando la atención sobre estilos de construcción de aplicaciones basados en agilidad, simplicidad y capacidad de expresión.
Por el otro, Heroku, desde sus humildes orígenes como una plataforma pequeña de aplicaciones en la nube en el 2007, siempre intentó hacer que el desarrollo y ejecución de las aplicaciones web fuese algo más sencillo y ordenado, y desde entonces su servicio creció para establecerse entre los mejores en satisfacción de los usuarios/desarrolladores y calidad de ejecución, además de mantener el espíritu de soporte a los emprendedores brindando la posibilidad de comenzar con niveles gratuitos que permiten construir cosas reales y empezar a invertir dinero cuando el negocio realmente empieza a despegar.
La combinación sólo puede deparar más fuerza en esa dirección sana de seguir impulsando a la "competencia", ya sean otras plataformas o lenguajes, en la dirección de la productividad y sencillez pero siempre basadas en una experiencia de desarrollo divertida y libre de stress.
Es interesante saber que Heroku planea seguir adelante con su soporte a otros lenguajes/entornos, como Node.js o Clojure (ambos soportados actualmente) mientras que el rol de Matz (y su pequeño equipo de colaboradores) será seguir desarrollando Ruby. Seguramente la cercanía aporte muchas cosas buenas a la plataforma en general, y probablemente le permita a Matz seguir jugando con otros lenguajes, algo que nunca dejó de hacer a pesar de su liderazgo en el desarrollo de Ruby.
Como regalo final les dejo un video de Matz recorriendo un poco la historia de Ruby antes de contar los planes para la próxima versión 2.0, que comenzó el desarrollo a fines del año pasado. En el video Matz habla en su tradicional simil-inglés, que espero que entiendan (tiempo total: ~35 minutos).
Ingrid tiene un background mixto entre sus estudios de filosofía en UBA y sus 16 años trabajando en desarrollo de software, que canalizó volcándose a las metodologías ágiles, poniendo fuerte foco en la dinámica de grupos y las relaciones humanas.
Pueden ver, además del video debajo, la presentación de Ingrid embebida en este post de su blog.
El video está dividido en 3 segmentos, y dura en total unos 50 minutos.
El matemático Alfréd Rényi decía que "un matemático es una máquina que convierte café en teoremas", frase que usualmente se le atribuye a su compatriota y colega Paul Erdös, quien solía repetirla.
Los programadores somos de alguna manera aparatos para convertir cafeína en algoritmos, lo que se hace explícito en la tradición de Java, JavaScript y el reciente CoffeeScript, todos inspirados en este alcaloide de venta libre.
Siguiendo la tradición cafetera, Maurice Machado ha colaborado con un reciente experimento notable basado en Node.js y CoffeeScript. Como breve recordatorio, CoffeeScript es una sintaxis simplificada de JavaScript, con un estilo más sucinto, bastante similar a Ruby, que se está haciendo tan popular que ya viene integrado en la distribución de Ruby on Rails 3.1, por ejemplo.
Lo que Maurice generó con CoffeeKup es un lenguaje específico de dominio (DSL) sobre CoffeeScript para generar el marcado completo de la página. Esto es, en lugar de escribir HTML, podemos escribir directamente toda la estructura de la página en CoffeeScript.
doctype 5
html ->
head ->
meta charset: 'utf-8'
title "#{@title or 'Untitled'} | My awesome website"
meta(name: 'description', content: @desc) if @desc?
link rel: 'stylesheet', href: '/stylesheets/app.css'
style '''
body {font-family: sans-serif}
header, nav, section, footer {display: block}
'''
script src: '/javascripts/jquery.js'
coffeescript ->
$().ready ->
alert 'Alerts are so annoying...'
body ->
header ->
h1 @title or 'Untitled'
nav ->
ul ->
(li -> a href: '/', -> 'Home') unless @path is '/'
li -> a href: '/chunky', -> 'Bacon!'
switch @user.role
when 'owner', 'admin'
li -> a href: '/admin', -> 'Secret Stuff'
when 'vip'
li -> a href: '/vip', -> 'Exclusive Stuff'
else
li -> a href: '/commoners', -> 'Just Stuff'
section ->
h2 "Let's count to #{@max}:"
p i for i in [1..@max]
footer ->
p shoutify('bye')
Como puede verse, se declara la estructura jerárquica de la página (cabecera y cuerpo), con sus atributos internos, y pueden anidarse los elementos como párrafos, divs, listas, y demás. Y claro, puede embeberse código en cualquier lado. No hay una diferencia directa entre la plantilla y el código.
Parece una postura muy radical, pero me parece un espacio sumamente interesante a investigar. Los experimentos de Maurice estén disponibles en GitHub y no terminan en CoffeeKup. Hay otros relacionados, como Zappa y CoffeeScript-Bespin.
Como comentaba días atrás, se está organizando una nueva reunión de la comunidad Alt.NET en Buenos Aires, y la fecha final es el sábado 16 de julio, de 9:00 a 18:00 en las oficinas de Microsoft Argentina (gracias al anfitrión Miguel Sáez), en Bouchard 710, 4to piso, Ciudad de Buenos Aires.
Para quienes no conocen el formato Open Space, les dejo el enlace a esta guía.
Tradicionalmente el almuerzo se hace en el mismo lugar, con empanadas o pizzas, en un intervalo a mediodía, de manera de aprovechar al máximo este sábado geek.
Otra cosa importante es que aunque la selección de temas se produce por presentación y votación en el primer momento del evento, hay una wiki donde se pueden ir proponiendo temas posibles, de manera de ir generando ideas. Es importante animarse a proponer temas, recordando que el que propone no necesariamente tiene que exponer, si no que puede hacer un llamado a charlar sobre algo que no conoce bien o que le genera dudas.
Como último detalle antes de cerrar (y que puede generar algún debate en el Open Space) les dejo el video de la más reciente de las VAN de Alt.NET Hispano (y recuerden que ya hay 75 sesiones de cerca de dos horas disponibles para ver a demanda):
El tema es "Identity Providers, oAuth y Autenticaciones on-line", presentado por Carlos Peix y Nelo Pauselli.
El video que comparto esta vez tiene un par de cosas raras para este blog:
Está en inglés (fue grabado en la reciente Norwegian Developers Conference)
Presenta un producto pago (no abierto)
¿Por qué lo publico entonces? Porque en 6 minutos, Hadi Hariri, colega que participa también en el grupo Alt.NET Hispano, y al que oportunamente espero conseguir para presentar algo de esto en español, demuestra algunas características de ReSharper 6, un complemento con Visual Studio que algunos describieron en Twitter como "una IDE que utiliza Visual Studio como host", por sus increíbles capacidades.
Específicamente, y más allá de que uno programe o no en .NET y eventualmente no utilice Visual Studio, me parece notable el nivel de análisis en vivo que pueden hacer sobre código JavaScript. Como Hadi dice en un momento del video, ya no es un tema de "estático o dinámico" sino de las herramientas adecuadas. JetBrains, la empresa detrás de ReSharper (conocidos también por su IDE para Java IntelliJ IDEA y otras como PyCharm y RubyMine) me sorprende siempre por su capacidad de innovación y de resolución de problemas complejos alrededor de la comprensión y análisis de lenguajes de todo tipo.
Este video es de una de las reuniones mensuales de Agiles @ Buenos Aires, pero me había quedado en el tintero procesarlo y publicarlo, así que, con disculpas a Federico por la demora, acá va.
Federico es desarrollador y coach en metodologías ágiles en 10Pines, y anteriormente trabajó en EDS (hoy HP), Globant y otras empresas de software, involucrándose en proyectos muy interesantes.
Después de años utilizando metodologías ágiles y actuando como introductor en muchos equipos, se unió a 10Pines para dedicarle más tiempo a esta actividad de ayuda.
Mediante esta actividad encontró muchas veces una variedad de expectativas y objetivos respecto a la adopción de este paradigma, y de eso habla en esta sesión que presentó originalmente en Agiles 2010 en Lima y repitió en la reunión de Buenos Aires de marzo de este año.
Queda el video, entonces, dividido en 3 partes, que duran en total unos 50 minutos.
Mi invitado esta vez es Mariano Koldobsky, un experimentado trabajador al que conozco desde hace años, a raíz de conocernos en una empresa en que él trabajaba y yo daba consultoría, y reencontrarnos más tarde en la comunidad ágil.
Tiempo después logramos trabajar juntos por un tiempo, hasta hace poco cuando Mariano empezó a trabajar para bvision, que tienen oficinas cerca de su casa en La Plata, capital de la provincia de Buenos Aires.
Con Mariano compartimos la pasión por la programación, la electrónica y recuerdos de nuestra generación, ya que somos los dos bastante veteranos. Pero casualmente esas dos primeras aficiones nos llevaron a elegir como tema de nuestra sesión un ejercicio de programación y cableado, utilizando una placa Arduino, que es una plataforma de hardware abierto, ideal para realizar prototipos e implementaciones sencillas y caseras de dispositivos de control.
Como verán en el video, la placa se conecta por USB (anteriormente por puerto serie) y se programa en un lenguaje de programación propio (una especie de Processing, pero basado en C++ en lugar de Java).
Algo interesante de Arduino es que es la plataforma que tomó de base Google para desarrollar su propio Android Open Accessory Development Kit, con lo que conocerla ahora puede significar algo más que un mero pasatiempo.
El video dura un poco menos de 15 minutos, y espero que les resulte tan divertido como a nosotros grabarlo. ¡Al menos por una vez van a ver algo más que código!
El próximo 21 de julio (de 18:30 - 20:00; GMT -3; horario de Buenos Aires) el amigo Juan Gabardini, viejo compañero de aventuras, estará presentando un Webinar (un seminario via web) patrocinado por la buena gente de Kleer.
El tema es el uso de casos de prueba basados en ejemplos utilizando FitNesse, la plataforma de pruebas de aceptación basada en wikis creada por el tío Bob Martin y amigos en base al FIT original de Ward Cunningham (ambas herramientas de código abierto y gratuito).
El evento es en línea y gratuita, pero los interesados deben registrarse porque hay una cantidad máxima de asistentes (aunque no se bien cuál).
La sesión se presentará utilizando GoToMeeting, un servicio de conferencias en línea de Citrix que soporta Windows y Mac OS y utiliza un cliente que se descarga al momento de la conexión, por lo que recomiendo conectarse unos 10 minutos antes para estar seguros de que todo funciona correctamente.
El temario, según la invitación, es el siguiente:
¿Cómo logramos que los requerimientos sean claros tanto para los usuarios como para los desarrolladores?
¿Cómo lograr validar continuamente y con bajo costo que el producto cumpla con los requerimientos?
Veremos las especificaciones por medio de ejemplos, una técnica utilizada para lograr estos objetivos, y Fitnesse, una herramienta libre que soporta la técnica.
Fitnesse permite escribir los ejemplos (requerimientos) como tablas o historias, y ejecutar automáticamente estos ejemplos contra la aplicación, informando si la aplicación cumple con los resultados esperados.
(gracias a José Romaniello por descubrirme este interesantísimo lenguaje)
Cobra es un lenguaje multi-plataforma y multi-paradigma que combina una cantidad de características sumamente interesantes.
Es obra de Charles Esterbrook, y su autor describe sus principios de diseño de la siguiente manera:
Programación rápida y expresiva
Rápida ejecución
Tipado estático y dinámico
Calidad soportada a nivel del lenguaje
Por supuesto que suena ambicioso y vendedor, pero en principio, es bastante realista. Veamos cómo se soporta cada cosa:
Programación rápida y expresiva
Cobra tiene una sintaxis basada en Python (sobre todo) y Ruby, lo que lo hace mucho más legible que los lenguajes "con llaves y punto y coma". Entre otras cosas, en Cobra los bloques se determinan por indentación, las listas y diccionarios se pueden declarar como literales, hay comandos como print y assert de uso sencillo y poderoso, la manera de iterar y dividir listas es simple, y mucho más.
Un ejemplo rápido de la sintaxis, con la definición de una clase:
class Person
"""
Declaración de una clase. Este comentario documenta la clase misma
"""
var _name as String # Declara variables de instancia (no estáticas)
var _age as int
cue init(name as String, age as int) # Inicializador (constructor)
base.init
_name = name
_age = age
def sayHello # Métodos
# Los corchetes interpolan valores en las strings
print 'Hello. My name is [_name] and I am [_age].'
def divide(i as int, j as int) as int
""" Este comentario documenta este método """
assert j > 0 # Si el divisor
return i / j
Rápida ejecución
Esto es logrado a través del uso de tipos estáticos con inferencia permanente, sin perder las capacidades dinámicas para los casos necesarios.
La implementación actual de Cobra utiliza la Infraestructura Comun de Lenguajes (CLI) de .NET/Mono, por lo que el compilador genera código intermedio (IL) que a su vez es es llevado a código nativo por el motor de ejecución de .NET/Mono como en otros lenguajes.
Tipado estático y dinámico
La mayor parte de la resolución es estática y en tiempo de compilación, mientras que siempre que haga falta puede utilizarse resolución dinámica en tiempo de ejecución, basada en Reflection de .NET y apoyándose en técnicas específicas de optimización.
Veamos un ejemplo sencillo de una misma función declarada estáticamente:
def add(a as decimal, b as decimal) as decimal
return a + b
... o dinámicamente:
def add(a, b) as dynamic
return a + b
En la práctica, no son la misma función, ya que la primera opera solamente con números decimales, y la segunda con cualquier tipo que soporte la operación suma.
Obviamente la primer función es más rápida, ya que se verifica y compila, y no requiere más recursos que los operandos de un largo conocido (decimal), mientras que la segunda, al resolverse dinámicamente, es verificada en tiempo de ejecución y requieres más recursos para la conversión de parámetros, etc.
Por otro lado, contar con ambas variantes es lo ideal, ya que podemos aprovechar el contrato estricto de los tipos estáticos para gran parte de la aplicación, pero con la flexibilidad de los dinámicos para las porciones que son más variables, o para facilitar el prototipado.
Nótese que el soporte a tipos dinámicos de Cobra, comparado con el de C# o VB (a partir de .NET 4), es sintácticamente más sencillo, mucho más integrado a nivel del lenguaje.
Calidad soportada a nivel del lenguaje
Cobra soporta contratos de código (algo proveniente de Eiffel que .NET 4 soporta parcialmente), pruebas unitarias, comentarios para documentación y verificación de valores nulos en tiempo de compilación, todo como parte de su sintaxis.
Veamos como las pruebas unitarias quedan embebidas directamente como parte de un método:
class Utils
shared
def countChars(s as String, c as char) as int
"""
Returns the number of instances of c in s.
"""
test
assert Utils.countChars('', c'x') == 0
assert Utils.countChars('x', c'x') == 1
assert Utils.countChars('X', c'x') == 0 # case sensitive
assert Utils.countChars(' ! ! ', c'!') == 2
body
count = 0
for ch in s
if c == ch
count += 1
return count
Las aserciones, además, pueden usarse en cualquier parte del código, y arrojan una excepción con información útil para depuración si no se cumplen (no son un IF).
Los contratos embebidos en el código permiten especificar pre y post-condiciones a los métodos, garantizando la consistencia antes de entrar y después de retornar el valor final. Por ejemplo:
class Customer
var _contacts as List<of Contact>
get contacts from var
def addContact(contact as Contact)
require # Arroja excepción si algo no se cumple ANTES de entrar
contact not in .contacts
contact.name
contact.customer is nil
ensure # Arroja excepción si algo no se cumple DESPUES de salir
contact.customer == this
.contacts.count = old .contacts.count + 1
body
contact.customer = this
_contacts.add(contact)
Y otra característica muy buena de seguridad es que los parámetros o tipos que pueden recibir nil (llamado como en Smalltalk o LISP), son los que se declaran como tales, agregando al sufijo "?" al tipo, como en:
def bar(s as String?)
if s # Es igual que preguntar "if s is not nil"
print Utils.countChars(s, c'x')
Cobra está escrito en Cobra
Una característica más que quiero remarcar es que este lenguaje está escrito sobre si mismo. Por supuesto hay una parte del compilador escrita para la plataforma nativa (C# en este caso), pero el resto está escrito en Cobra mismo, lo que hace que el lenguaje tenga un nivel de depuración y prueba mayor que otros que se construyen generalmente sobre lenguajes de más bajo nivel. Esto está sucediendo en otros lenguajes a posteriori, como en el caso de PyPy o Rubinius, pero en Cobra fue un principio de diseño.
Personalmente me parece uno de los lenguajes "experimentales" más interesantes y completos que he visto en los últimos tiempos, en parte porque se apoya en una plataforma que ya ofrece muchos servicios, y en parte por algunas de sus características maduras que y las herramientas con que ya cuenta (compilador, ejecutor de pruebas unitarias, generador de documentación, coloreador de sintaxis, etc).
Y también cuenta con soporte parcial en algunas IDEs y editores:
Visual Cobra es un complemento para Visual Studio que reconoce y colorea la sintaxis.
Naja es una IDE completa escrita en Cobra que ademas del coloreo de sintaxis tiene soporte para lista de tareas basada en comentarios, soporte para proyectos y un diseñador de formularios que genera código Cobra.
Y si uno prefiere un editor de texto hay muchos para los cuales hay complementos para soportar la sintaxis, incluyendo gedit, Notepad++, UltraEdit, Vim y TextMate (el que estoy usando yo), y mucho más para elegir según la plataforma que cada uno usa. Y para cualquier otro caso existe un detalle de las palabras clave y modificadores, de manera que en cualquier editor se puede partir del soporte para Python y cambiar estas listas.
Finalmente, dejo este video de la presentación de Esterbrook en el Lang .NET Symposium 2008. Aunque la implementación del lenguaje maduró bastante desde entonces, muchos de los principios siguen igual.
Apple realizó su conferencia principal para desarrolladores, como todos los años, e imagino que la mayoría ya debe haber visto al menos algún compilado de la sesión de apertura, en la que se lanzaron Mac OS Lion, iOS 5 y iCloud, entre otras cosas.
Para quienes no lo vieron, dejo al final el video de esa sesión completa, aunque advierto que dura 158 minutos (casi 2 horas).
Si no tienen tiempo, pueden buscar en la web alguno de los compilados que muestran los anuncios más sobresalientes. Los hay super-comprimidos de 60 segundos, y algunos más detallados de unos 10 minutos.
Sin embargo, quienes quieran abundar en más información, no menos, ya pueden ver en video todas las sesiones (un centenear) de la conferencia, incluyendo algunas que captaron mi interés como (mi usual lista arbitraria; el sitio requiere un usuario gratuito registrado):
En esa sesión mi par es Diogenes Moreira, amante de la Orientación a Objetos que a pasado por múltiples tecnologías desde Cobol y PowerBuilder hasta Java y C#, siempre con su corazón cerca de Smalltalk.
Diogenes trabaja actualmente para Ilon SA y aunque tiene múltiples responsabilidades no deja de programar junto a su equipo. Participó en varios proyectos de código abierto, incluyendo colaboraciones para Pharo.
Nos conocemos por amigos comunes y por el grupo Agiles de Buenos Aires, y casualmente durante una de las reuniones mensuales de éste nos escapamos un rato a grabar este video en que hacemos algunos ejemplos con Seaside, un framework web para Smalltalk.
Como acompañamiento del video, dejo esta presentación de Esteban Lorenzano, en la que se recorren varias de las características que Diogenes comenta mientras escribimos los ejemplos:
Sin más preámbulos, el video, que dura aproximadamente 35 minutos. Estoy usando un servicio que brinda mucho mejor calidad de video (sobre todo para el código), pero tengan paciencia porque el reproductor puede tardar varios segundos (a veces casi un minuto) en empezar.
El infatigable equipo detrás de Heroku (la plataforma como servicio recientemente adquirida por Salesforce.com) está sumando a su infraestructura, creada inicialmente para simplificar el despliegue de aplicaciones Ruby (Rails, Sinatra u otros frameworks) la capacidad de alojar aplicaciones para Node.js
Ya hablé antes sobre Node.js, y como esperaba, este es el año en que el modelo de aplicaciones JavaScript del lado cliente y servidor comienza a consolidarse. El que una plataforma madura y robusta como Heroku facilite la ejecución de este tipo de arquitecturas potenciará muchísimo su uso.
Algo interesante que están haciendo en Heroku, siguiendo su estilo de pensar no sólo la solución sino el flujo de trabajo completo de desarrollo, es agregar mayor nivel de soporte a operaciones desde la línea de comandos, que es el ámbito donde los desarrolladores tienen mayores posibilidades de interacción desde el principio de los tiempos.
Como describen en este post, están agregando soporte a operaciones desde la consola de comandos, que permiten ejecutar procesos aislados (cada una de las líneas siguientes inicia un proceso en una instancia virtual, llamadas dyno, totalmente nueva, ejecuta el comando y baja la instancia):
$ heroku run date
$ heroku run curl http://www.google.com/
$ heroku run rails console
$ heroku run rake -T
$ heroku run rails server
Por supuesto que levantar un servidor de Rails para que inmediatamente después termine no tiene gracia en la mayoría de los casos, por lo que existe una manera de empaquetar procesos en un archivo Procfile, que simplemente declara los componentes necesarios, como por ejemplo:
web: node web.js
worker: node worker.js
Que crea una aplicación Node.js con dos componentes (un servidor web escuchando tráfico externo y un servicio interno para procesos intensivos, un modelo clásico en aplicaciones en la nube).
La gracia de este modelo es el mecanismo de escalamiento. Una vez que una aplicación está desplegada de esta manera, para escalarla basta usar un comando como:
$ heroku scale web=10 worker=50
Scaling web processes... done, now running 10
Scaling worker processes... done, now running 50
Como siempre, esto es un resumen, y recomiendo leer el post original, seguido de la segunda parte (dos más están por llegar) donde se presenta en más detalle el soporte para Node, incluyendo también una excelente descripción de que es y que no es Node para los recién llegados.
Uno de los objetivos de HTML5 es unificar el manejo de media para todos los navegadores y plataformas, pero hasta ahora, por cuestiones de indefinición de estándares, por temas de apertura, licenciamiento o comodidad tecnológica entre los jugadores del mercado, esto no ha sido sencillo.
Para solucionar este problema, el prolífico John Dyer escribió (y liberó bajo licencia GPL v2/MIT) MediaElement.js
Se trata de un reproductor de audio/video en JavaScript, como su nombre indica, que soporta una multitud de navegadores (los que soportan HTML5 y los que no) y unifica mucho más el soporte de codecs para diferentes formatos de video.
Para simplificar el uso manteniendo el soporte entre plataformas, el reproductor utiliza el mismo API en todas, basado en los tags <audio> y <video> de HTML5, implementándolos en los navegadores que no los reconocen, delegando el soporte a reproductores en Flash o Silverlight, pero que emulan exactamente el reproductor nativo.
De esta manera, el uso de estos elementos es idéntico en todos los navegadores para el productor del contenido, y la adecuación se produce en el cliente, que probablemente ya tenga los complementos necesarios descargados. La ventaja principal es que la manera de interactuar con los activos de audio o video es siempre igual.
El siguiente cuadro muestra el soporte para todos los navegadores, y la manera en que se soportan dependiendo de la plataforma:
Como siempre, el soporte se limita más en los dispositivos móviles, sobre todo en iOS, pero nótese que los navegadores de escritorio están cubiertos por completo.
La instalación de MediaElement es muy sencilla y está bien descripta en el sitio. Del lado del cliente, básicamente se reduce a incluir esta biblioteca y hoja de estilos:
Y para incluir el reproductor, utilizando el caso más extremo para dar soporte completo a todo, este es el marcado HTML (obviamente sin necesidad de incluir todos los comentarios):
<video width="320" height="240" poster="poster.jpg" controls="controls" preload="none">
<!-- MP4 en Safari, IE9, iPhone, iPad, Android, y Windows Phone 7 -->
<source type="video/mp4" src="myvideo.mp4" />
<!-- WebM/VP8 en Firefox4, Opera, y Chrome -->
<source type="video/webm" src="myvideo.webm" />
<!-- Ogg/Vorbis en versiones viejas de Firefox y Opera -->
<source type="video/ogg" src="myvideo.ogv" />
<!-- Opcional: Agregar subtitulos para diferentes lenguajes -->
<track kind="subtitles" src="subtitles.srt" srclang="en" />
<!-- Opcional: Agregar capítulos -->
<track kind="chapters" src="chapters.srt" srclang="en" />
<!-- Ante-último recurso: sólo para navegadores sin HTML5 ni JavaScript -->
<object width="320" height="240" type="application/x-shockwave-flash" data="flashmediaelement.swf">
<param name="movie" value="flashmediaelement.swf" />
<param name="flashvars" value="controls=true&poster=myvideo.jpg&file=myvideo.mp4" />
<!-- El peor de los casos: dejo una imagen -->
<img src="myvideo.jpg" width="320" height="240" title="No tiene manera de reproducir video" />
</object>
</video>
El reproductor en si soporta diferentes estilos, puede controlarse programáticamente desde JavaScript, tiene montones de opciones como tamaño para el marco de video o audio, volumen, reproducción en bucle, subtítulos (incluyendo traducción automática via Google translate), y más.
Creo que para cualquiera trabajando seriamente en media en este momento este reproductor es una de las soluciones más completas disponibles.
Cada tanto la comunidad Alt.NET se pone de acuerdo para realizar un Open Space en Buenos Aires, como en muchas otras partes del mundo. Ya he cubierto ediciones anteriores en este blog, y ahora me toca informar sobre la organización de una nueva reunión.
Como suele ocurrir, hay mucha gente que está interesada pero aún no se ha acordado la fecha definitiva, aunque hay consenso en hacerla durante el mes de julio. Para votar por la fecha que prefieran los interesados, estamos utilizando este mecanismo:
¡No sean tímidos! Todo el que esté realmente interesado en participar puede elegir qué sábado le queda mejor. Tengan en cuenta que usualmente s desde las 9 de la mañana hasta las 6 de la tarde, con la interrupción del almuerzo que se hace in-situ. Es probable que el lugar sea Microsoft de Argentina, en Bouchard 710, 4to piso, Ciudad de Buenos Aires.
Y como siempre, aprovecho para recordar que además de estas reuniones presenciales que se organizan esporádicamente en distintas ciudades, el grupo Alt.NET Hispano organiza reuniones virtuales en forma semanal (a veces más de una por semana), que se anuncian en la lista de distribución y en el calendario de reuniones del sitio.
Estas reuniones quedan grabadas y pueden verse a demanda una semana o dos después de su ejecución, y el grupo ya lleva (a hoy) 73 reuniones que pueden verse en línea o descargarse desde el histórico de reuniones.
Rubinius es una implementación de Ruby que tiene la característica principal de estar escrito mayormente en Ruby.
La máquina virtual está escrita en C++ y utiliza LLVM para convertir el bytecode en el código nativo del procesador destino, pero el compilador de los bytecodes y la gran mayoría de las bibliotecas están escritas en Ruby. Este nucleo utiliza un recolector de basura muy optimizado y permite extensibilidad en C que soporta las mismas extensiones en este lenguaje que utiliza el intérprete estándar de Matz (conocido como MRI).
El siguiente diagrama muestra la distribución de componentes de Rubinius:
Uno de los desafíos de Rubinius siempre fue medir el nivel de compatibilidad contra la implementación de Matz, por lo que tempranamente empezaron a trabajar en RubySpec, una serie de pruebas que funcionan como la especificación del lenguaje, ya que éste no tenía una originalmente y por sus propias características de meta-programación, es especialmente complejo de validar.
Básicamente, Rubinius, hasta su última versión estable, soporta Rails, Rake, RSpec, Nokogiri, Mongrel y prácticamente todas las bibliotecas y frameworks hasta Ruby 1.8.x.
La novedad es que el equipo acaba de liberar la versión preliminar 2.0, que fundamentalmente soporta Ruby 1.8.7 y 1.9.2, y funciona bajo Windows, pero además utiliza un nuevo mecanismo de threading realista que aprovecha los múltiples núcleos de los procesadores modernos.
Adicionalmente, el equipo migró el repositorio a GitHub. Para los interesados en el desarrollo de lenguajes, vale la pena al menos pegarle una mirada.
Uno de los principios de diseño del framework .NET, o más específicamente del CLI (Common Language Infrastructure) es, como su nombre lo indica, permitir implementar fácilmente una variedad importante de lenguajes.
El CLI es una pieza estandarizada ante ECMA como un estándar abierto, y es lo que ha permitido la creación de implementaciones abiertas de .NET como Rotor y Mono.
Pero también ha permitido la implementación de muchos lenguages (más allá de Microsoft) que comparten todo el ecosistema de herramientas y bibliotecas disponibles.
Nemerle es uno de estos casos. Desarrollado en la Universidad de Wroclaw, Polonia, se trata de un lenguaje de tipos estáticos, casi un superset de C#, que soporta estilos de programación funcional y orientada a objetos, metaprogramación, lenguajes específicos de dominio y mucho más. Al estar basado en el CLI genéricamente, funciona en .NET y en Mono por igual.
Siendo un superset, es posible compilar (con un par de toques en el archivo .csproj) fuentes C# en Nemerle.
Dos de las características más distintivas de Nemerle son la inferencia de tipos y el uso de macros.
Veamos algunos ejemplos de código, con inferencia de tipos:
def d = Dictionary ();
d.Add ("Code and Beyond", 42);
foreach (s in args) {
...
}
Notese que no hace falta inicializar los tipos del diccionario, que son declarados y chequeados a partir del primer uso.
En el caso de las macros, pueden escribirse cosas como:
ExecuteReaderLoop ("SELECT nombre, apellido FROM personas WHERE nombre = $miNombre", dbcon,
{
System.Console.WriteLine ("Persona: {0} {1}", nombre, apellido)
});
que enmascaran la creación del SqlCommand y el SqlReader, la clásica iteración y la obtención de las strings para los dos campos leídos, pero es importante ver que es mucho más que una función de una biblioteca, ya que en este caso se está interpretando la string conteniendo la sentencia SQL y generando el código chequeado correspondiente.
Nemerle también tiene interpolación de strings más eficiente que en C#, ya que se ejecuta en tiempo de compilación, como en:
$"Me llamo $Nombre y tengo $Edad años."
donde las variables reemplazadas son chequeadas por el compilador, a diferencia de utilizar String.Format, donde se realizan en tiempo de ejecución.
Es muy interesante además la sencillez para definir Macros, que no tienen nada que ver con las de C, y son descendientes directas de las macros de LISP. Veamos este caso que define un bucle hacia atrás:
Una vez más, la imparable Fundación Argentina de Smalltalk (FAST) organiza la conferencia internacional del lenguaje decano de la orientación a objetos: Smalltalks 2011.
El pasado 19 de julio el grupo 
El 
