.NET Reflector (gratis de nuevo para usuarios existentes) y alternativas

Desde hace una semanas hay mucho ruido por la decisión repentina de la gente de RedGate de empezar a cobrar .NET Reflector, que siempre había tenido una versión gratuita.

Para poner un poco de contexto, cuento un poco de la historia y utilidad de Reflector:

Un componente fundamental del framework .NET es el CLR, un runtime de ejecución para múltiples lenguajes. Cualquier lenguaje que se quiera implementar en .NET necesita que su compilador (o intérprete) termine generando IL (lenguaje intermedio), una especie de lenguaje ensamblador virtualizado, que aprovecha montones de servicios comunes de la plataforma y garantiza la compatibilidad e interoperabilidad de tipos y servicios entre cualquier componente, sin importar en qué lenguaje fue escrito originalmente.

Desde los primeros días se hizo evidente (y es una característica de diseño) que tomando un assembly (un componente binario) de .NET, era fácil analizar el código fuente en IL, e incluso entre las herramientas básicas del framework se incluye el desensamblador ILDasm. Proteger los componentes contra descompilación es un tema recurrente con alternativas como la obfuscación, y que muchos consideramos irrelevante, pero eso es tema para otro momento.

Lo cierto es que para la mayoría de los mortales analizar IL no es trivial, por lo que a mediados de los 2000 Lutz Roeder creó Reflector, una herramienta que permitía descompilar un assembly a C# (hoy día también a VB y F#). Lutz mantuvo siempre esta herramienta disponible para toda la comunidad (no como código abierto, pero si gratuita) y la evolucionó constantemente a lo largo de los años, convirtiéndola en una de las principales recomendaciones para cualquier desarrollador .NET.

Reflector no sólo descompila componentes, sino que además facilita muchísimo la navegación dentro del código, tiene una excelente estructura para extensiones que ha favorecido la aparición de extensiones extraordinarias; unas tres docenas en el sitio de Codeplex que las agrupa. Pero también tiene muchísima funcionalidad para analizar tipos y dependencias, navegar objetos, mejorar posibilidades de depuración y mucho más.

En el año 2002 Lutz fue contratado por Microsoft y desde entonces trabaja en el grupo de Microsoft Expression. Con el tiempo notó que era dificil mantener el nivel de compromiso con su herramienta e hizo un acuerdo con RedGate, una compañía que se comprometía a continuar desarrollando y manteniendo una versión gratuita, con opción a producir ediciones pagas con funcionalidad adicional.

Todo iba bien con este acuerdo, hasta que RedGate anunció hace unos meses que a partir de la versión 7.x la herramienta tendría sólo ediciones pagas. El equivalente de la versión gratuita pasó a costar 35 dólares, lo que no es mucho para alguien que la usa frecuentemente, pero en otros casos puede resultar más complicado, y la comunidad no tomó la noticia con mucha alegría.

Peor aún, poco más tarde RedGate anunció que las versiones actuales pasarías a ser pagas también, y la situación con la comunidad empeoró cuando utilizaron el mecanismo de auto-actualización de Reflector para forzar a los usuarios a actualizar a una versión con fecha de expiración.

El revuelo no se hizo esperar y finalmente, ayer RedGate (más vale tarde que nunca), anunció públicamente que reconsideró el tema. Los usuarios de Reflector 6.x podrán actualizar a una versión que continuará siendo gratuita (si lo hacen hoy, actualizarán a una con fecha de expiración que puede ignorarse, porque la versión perpetua se recibirá en la próxima actualización).

Una aclaración importante: RedGate no brinda manera de descargar la versión 6.x, con lo que este mecanismo sólo funciona para quienes ya lo tienen instalado. La versión gratuita no es parte de la oferta de RedGate.

Para quienes el nivel de uso no justifica invertir 35 dólares, sin embargo, existen alternativas interesantes, algunas desde hace mucho tiempo, otras surgidas o potenciadas por el conflicto alrededor de Reflector:

MonoDevelop, Cecil.Decompiler y MonoReflector

Esta herramienta que está disponible en MonoDevelop (la IDE para Mono) también puede usarse sobre assemblies de .NET (Mono al fin y al cabo genera el mismo IL). Como casi siempre, esto no es algo interno de la IDE, sino que utiliza parte de la bilbioteca Cecil de Mono (que tiene muchísima funcionalidad para analizar y generar IL) incluyendo directamente el servicio de descompilación como puede leerse en este post del autor (Jean-Baptiste Evain, del equipo Mono en Novell).

Basado en Cecil.Decompiler, Jonathan Dickinson publicó MonoReflector, una interfaz WinForm para la biblioteca. Como la incorpora directamente, no es necesario instalar Mono: corre directamente sobre .NET.

ILSpy

Esta es una herramienta de código abierto iniciada tras el anuncio de RedGate por el equipo de SharpDevelop (una IDE de código abierto para .NET).

JustDecompile

Telerik acaba de liberar la beta de su herramienta gratuita JustDecompile (no de código abierto hasta donde veo).

 

Finalmente, JetBrains, creadores de ReSharper, DotTrace y muchas otras herramientas poderosas (para .NET y otras plataformas), anunció que está trabajando en un descompilador que se espera sea gratuito también, pero por ahora sólo se sabe que se llamará DotPeek (nombre elegido en un concurso por la comunidad)

 

 

Más videos desde el pasado: Agiles 2008

Como comenté la semana pasada, Google Video decidió no mantener más el contenido que se había subido en su momento a ese servicio (previo a la compra de YouTube por parte de Google), pero en estos días mejoraron la manera de manejar el proceso, permitiendo mover de manera más directa el contenido hacia YouTube (cosa que no podía hacerse antes aun manualmente en el caso de videos de más de 15 minutos, que YouTube no soporta).

El resultado es que -afortunadamente- pude pasar todo el contenido que tenía hacia YouTube, y hoy sigo compartiendo un poco desde este arcón de los recuerdos. En este caso, dejo una serie de videos de Agiles 2008, y aprovecho para mencionar algo importante sobre la edición de este año del evento:

Ya está abierta la Convocatoria a Ponencias para Agiles 2011, en Buenos Aires.

Todos aquellos interesados en proponer sesiones o talleres, o en ver las propuestas hechas por otros y votar por ellas (lo que ayuda a la organización en la definición del programa final) puede visitar la página correspondiente en la sección de programa del sitio.

Volviendo a los videos, aquí en primer lugar uno de una sesión en español:

En ISO 9000 Ágil, Diego Gonzalez, de Lagash (a quienes felicitamos por sus flamantes 10 años), contaba cómo hicieron para certificar bajo normas ISO su proceso de desarrollo, basado en métodos ágiles.

Los siguientes videos son mayormente en inglés, con alguna acotación en español. Dejo en primer lugar el Panel de Cierre de Agiles 2008, que contó con la participación de varias de las figuras importantes que vinieron a visitarnos, y donde además podrán notar que se generó un debate algo tenso. Sobre el final, pueden saltear la parte en que aparezco balbuceando en el cierre del evento.

También dejo la sesión de Micah Martin sobre pruebas de aceptación con Fitnesse:

Y finalmente la sesión de mis amigos Matt Gelbwaks y Emilio Gutter sobre cómo mantener prácticas ágiles con equipos distribuidos.

Manos de Mono

Aunque suene raro, Manos de Mono es el nombre de un framework liviano para desarrollo web, soportado por Mono (la implementación abierta de .NET) e inspirado en Tornado, Sinatra, Node.js y otros mecanismos web recientes.

Creado por Jackson Harper, miembro del equipo de Mono en Novell, este framework intenta simplificar mucho el desarrollo web, evitando abstracciones y herramientas. Jackson usa como inspiración esta elegante frase de Alan Kay (inventor de Smalltalk, entre otras cosas):

"Las cosas simples deben ser simples. Las cosas complejas deben ser posibles."

Manos está concebido para ser simple de usar, fácil de probar y brindar altísimo rendimiento, sin necesidad de utilizar un servidor web (ni Apacha, ni IIS). Las aplicaciones desarrolladas con Manos incluyen el servidor web como parte del paquete, facilitando también la instalación y actualizaciones, y eliminando toda configuración.

Algunas de las características más interesantes de Manos son:

• El servidor es muy escalable y no-bloqueante, es decir que no usa threads separados para cada petición, sino un loop de eventos, como hace Node.js (mas información sobre éste último en este post anterior).
• Un sistema de cañerías (pipes) HTTP que facilita tratar cualquier petición o respuesta antes o después de que el framework los enrute.
• El enrutamiento puede realizarse por convención, propiedades o métodos HTTP. Todas las rutas pueden definirse con expresiones del estilo "/Articulo/{titulo}/{pagina}".
• Al generar un nuevo proyecto, Manos produce una serie de archivos básicos basados en el HTML5 Boilerplate (cubierto en este otro post), que después se personaliza por medio de un motor de plantillas muy rápido. Las vistas pueden generarse con cualquier editor y son casi HTML puro, pero son compiladas en tiempo de ejecución para maximizar el rendimiento.
• La interfaz principal de Manos es una línea de comandos que permite crear, construir o iniciar las aplicaciones sin necesidad de ninguna IDE.
• El diseño es totalmente modular, permitiendo extender Manos fácilmente, lo que puede facilitar que el ecosistema crezca con contribuciones de la comunidad.

Para crear una aplicación Monigote (por ejemplo), basta abrir una consola y escribir:

manos --init Monigote

y esto crea una carpeta Monigote con los archivos Monigote.cs, StaticContentModule.cs y una subcarpeta para las hojas de estilo y librerías Javascript (incluye jQuery, Modernizr, y otras). Los primeros archivos son programs C#, como se habrán dado cuenta. El primero es el punto de entrada de la aplicación, y el segundo se encarga de servir el contenido estático desde la sub-carpeta creada: scripts, imagenes, estilos, etc.

Dentro de Monigote.cs podemos incluir algo tan sencillo como:

Get ("/", ctx => ctx.Response.End ("¡Hola, Monigotes amigos!"));

Y esta acción procesa directamente la ruta raíz ("/"), respondiendo con un saludo.

Por supuesto que hay mucho más, pero este es el estilo de desarrollo en general. Antes de ejecutar la aplicación debemos construirla con el comando:

manos --build

Y para ejecutarla simplemente ejecutamos:

manos --server

Y la aplicación inicia, accesible en el localhost, en el puerto 8080 para pruebas.

Más detalles en este tutorial, y la documentación completa.

Videos desde el pasado: arquitectura

Toda empresa toma decisiones dolorosas, debatibles o erróneas, pero finalmente tenemos que aceptarlas aunque no nos gusten si están dentro de los términos que aceptamos en su momento.

En estos días, Google anunció que va a eliminar el contenido subido a Google Video (que ahora es solamente un índice), lo que significa que varios millones de videos van a perderse en el tiempo. El 29 de abril (en 10 días más) todo este material se va a ir, pero al menos dejaron la posibilidad de que uno descargue los videos que había subido y los mueva a otro lado.

Lamentablemente lo que se puede descargar no es el video original, sino la versión en formato FLV procesada por Google en su momento (estimo que el original no deben haberlo guardado), así que los que pude recuperar no están en el mejor de los formatos, pero me pareció interesante la oportunidad de compartirlos.

En esta primera tanda comparto tres sesiones mías del año 2007, presentadas dentro de una serie sobre arquitectura de software en el MUG, que di a lo largo de varios meses entre Buenos Aires y Rosario. No todas quedaron registradas, pero estas tres si, y aunque el tiempo se nota, las republico porque en su momento tuvieron buena recepción.

La primer sesión es una introducción al modelo arquitectónico REST (Representational State Transfer), que hoy está sumamente difundido, pero en aquel momento todavía era algo novedoso. Sobre el final menciono un libro de Rails que en esa época todavía no era RESTful por omisión.

Los dos siguientes son parte de una serie de Casos de Arquitectura, que eran charlas en las que analizaba la manera en que estaban construidas algunas aplicaciones fuera de lo común, en particular en cuanto a escalabilidad, que era un tema menos frecuente en ese entonces (antes de la explosión de las redes sociales, por ejemplo). Además de las sesiones sobre Joost y Google Search que publico aquí abajo, recuerdo haber hablado sobre Second Life, YouTube (a meses de haber sido adquirido por Google), EBay y Amazon, entre otros.

El primero de los dos casos, Joost, aún existe pero se convirtió en un sitio web de nicho que perdió la gracia del proyecto original que utilizaba una red peer-to-peer para transmitir video en muy buena calidad con un consumo limitado de ancho de banda.

El segundo caso lo dediqué a Google Search, que a pesar de haber crecido muchísimo, sigue trabajando sobre premisas similares. Muchas de las tecnologías que explico en la sesión, como Bigtable, el Google File System o MapReduce están ahora disponibles como proyectos de código abierto o como parte de Google App Engine.

Rails 3.1 incluirá jQuery, CoffeeScript y Saas

La próxima entrega de Ruby on Rails, la versión 3.1, incluirá por omisión estas librerías como parte de todo nuevo proyecto.

Por supuesto que ya ha habido mucha discusión al respecto en la comunidad Rails, pero como siempre, la decisión está tomada por DHH y sus secuaces, y al fin y al cabo, cambiar los defaults no es complejo (basta alterar un par de líneas en el gemfile).

Pero repasemos un poco de que se tratan estos cambios:

Hasta ahora la librería estándar de Javascript que Rails agregaba por omisión era Prototype, pero como la mayor parte de la gente hoy día utiliza jQuery (lo que demuestra que no es tan complejo cambiar estas cosas), decidieron hacer oficial el cambio.

Los otros cambios son más dramáticos para algunos, y es la inclusión por omisión de CoffeScript y Saas.

Sobre CoffeeScript escribí un post hace poco, así que voy a evitar repetirme, pero básicamente es una sintaxis simplificada de Javascript, que facilita escribir la parte cliente de aplicaciones web (aunque también se usa a veces del lado del servidor, en conjunto con Node.js).

Saas, por su parte, es una sintaxis alternativa para hojas de estilo en cascada (CSS).

Históricamente tuvo dos sintaxis, la original es la indentada (con archivos de extensión .saas), inspirada en el lenguaje de templates Haml (también muy difundido en el ambiente Ruby), y en lugar de usar llaves y punto y comas para delimitar bloques, se basa en indentación, como en este ejemplo:

#main
  color: blue
  font-size: 0.3em

  a
    font:
      weight: bold
      family: serif
    &:hover
      background-color: #eee

La nueva sintaxis se llama SCSS y es un superset de la sintaxis CSS3 que utiliza archivos de extensión .scss. Esta es la que impulsan desde Rails, y en este caso no se remueven las llaves y punto y comas, sino que el foco está en mejorar las posibilidades de definición, por ejemplo, soportando anidamiento de estilos:

#navbar {
  width: 80%;
  height: 23px;

  ul { list-style-type: none; }
  li {
    float: left;
    a { font-weight: bold; }
  }
}

Y también variables, como en:

$main-color: #ce4dd6;
$style: solid;

#navbar {
  border-bottom: {
    color: $main-color;
    style: $style;
  }
}

a {
  color: $main-color;
  &:hover { border-bottom: $style 1px; }
}

Pero también hay soporte para mixins (a la Ruby), herencia de selectores, y más características.

Al igual que en el caso de CoffeeScript, Saas va a estar integrado al framework, de manera que nosotros editamos los archivos en estos lenguajes y automáticamente se generan sus equivalentes .js y .css sin mayores inconvenientes. En ambos casos, llegado el momento de tener que depurar el código directamente en el navegador (utilizando FireBug o herramientas similares) la distancia entre los lenguajes reales y estas sintaxis alternativas nunca es tan grande como para convertirse en un problema.

 

Node.js, Ruby y Python en... Windows Azure? (video)

Esta semana esta desarrollándose en Las Vegas, EEUU, la conferencia MIX11, en la que Microsoft realiza gran parte de sus anuncios para desarrolladores y diseñadores. A diferencia de PDC, que es la conferencia general para desarrolladores, MIX se orienta específicamente al desarrollo web o de aplicaciones cliente en general.

Como siempre, el criterio se amplía y aparecen, además de muchas presentaciones y anuncios esperables, algunas sesiones sumamente interesantes, como ésta de Steve Marx, uno de los personajes más innovadores dentro de Microsoft en los últimos tiempos.

En esta sesión, @smarx se dedica a subvertir Windows Azure, la plataforma de cloud computing, de la que él es el estratega técnico, para ejecutar sobre ella Node.js, Ruby, Python y también cosas como Cassandra o Tornado.

Veamos porque Steve me parece innovador:

• No usa Powerpoint (y todavía no lo echaron): estos son sus slides de la charla (puro html+css)
• Todos estos ejemplos están disponibles en su cuenta de GitHub
• De hecho, tiene construido un workflow que hace el deploy en Azure de algunas aplicaciones después del git push
• Sus diagramas son muy buenos (sólo comparables con los de @eugenio_pace, como se aprecia a la derecha).
• Y fundamentalmente, entiende y divulga la necesidad de soportar múltiples plataformas y alternativas para que Azure sea un ambiente exitoso, en contra del discurso preponderante de que se lo utilice solo en .NET o PHP.

En la sesión se muestra cómo utilizar estas herramientas sobre la infraestructura pelada de Azure, sin utilizar ni el SDK, aprovechando algunas de las características que se habilitaron recientemente a este fin como:

• Privilegios elevamos, para poder correr procesos como admin
• Startup tasks: tareas que se pueden ejecutar antes de que un rol o instancia arranque
• Control completo del IIS, incluyendo proxy reverso y FastCGI

Les dejo el video (en inglés) por si quieren entender un poco más el tema, especialmente los motivos por los cuales alguien querría hacer esto en Azure en lugar de otras plataformas. Si por alguna razón no se ve el video en este post (los mecanismos de incrustación de Channel 9 no parecen muy estables) pueden ver la sesión en la página original.

Mi pequeño homenaje

Tal vez notaron que los últimos días hubo pocos posts en este blog, en el que en general publico algo diariamente, de lunes a viernes.

El hueco se debe a que mi padre falleció la semana pasada, y obviamente mis prioridades no pasaron por aquí. Pero hoy retomo con un post que pretende ser mi pequeño homenaje para él, que fue quien incluyó en mi carrera técnica, y me acercó, de alguna manera, al mundo del software. Más allá del homenaje, espero que algunos lectores se sientan identificados, tal vez, con alguna anécdota que les recuerde su propio camino.

Mi padre fue tripulante de vuelo en Aerolíneas Argentinas por décadas. Mientras estudiaba para piloto, empezó a trabajar como auxiliar de vuelo, más tarde comisario de a bordo, hasta que logró pasar a un puesto de cabina con un puesto que hoy ya no existe: navegador / radio-operador (navro, en la vieja jerga aeronáutica).

Algunas de las primeras cosas que cautivaron mi imaginación por la tecnología fueron verlo trazando rutas sobre mapas gigantescos (desplegados eran como una sábana de dos plazas) utilizando compases y transportadores muy complejos, o revisar los enormes manuales de vuelo de los aviones, que en esa época los tripulantes llevaban encarpetados en pesadas valijas junto con sus instrumentos.

Pero el primer empujón real a lo que se convertiría en mi carrera fue cuando me regaló, traído en uno de sus viajes a EEUU, un kit de electrónica con componentes pre-armados, para usar sin soldador, mordiendo el extremo de los cables en pequeños resortes que conectaban a las patas de los diodos, transistores, resistencias, y demás componentes.

Hace mucho que perdí el rastro de aquel kit, y no conservo ninguna foto, pero encontré esta foto de un kit que es prácticamente idéntico al mio:

La caja de madera tenía una lamparita, capacitores, resistencias, diodos y transistores, un ferrite con bovina (para captar radio), algunas celdas solares, un potenciometro, un display de leds (para un único dígito), un parlante, y zócalos para baterías de distinto voltaje, entre otras cosas.

Con este kit aprendí, a fines de los '70, a hacer un flip-flop, algunas compuertas lógicas, y cosas más triviales como una radio, un sensor de luz y otros proyectos básicos. Pero bastó para mostrarme la base de la electrónica analógica y poner un tímido pie en la digital.

Como yo estaba en la escuela primaria y mi inglés era muy precario, mi viejo se tomó el trabajo de traducir todo el manual que se ve en la foto, con los 160 proyectos mencionados (algunos de más de una página) escribiéndolos en una máquina Olivetti portátil que llevaba y traía en cada vuelo durante un mes o dos, dedicando todo su tiempo libre a mi curiosidad.

Este juego me decidió a entrar en un colegio secundario con especialidad en electrónica, donde aunque no aprendí mucho del tema realmente, conocí a otros proto-hackers de los que me hice amigo y con quienes empezamos a molestar en los primeros negocios que traían computadoras personales al país (mucho antes de la IBM PC), convenciéndolos de que nos dejaran usarlas un poco a cambio de hacer demostraciones para los clientes interesados, ya que usualmente nadie sabía como usarlas.

La primer computadora que fue mía (al menos un tercio) también la financió mi papá. La compramos con otros dos amigos y la teníamos una semana cada uno, pero él nos desafió a que teníamos que mostrarle lo que aprendíamos a nuestros padres, más allá de los juegos, para asegurar que no perdiéramos oportunidad de aprender.

También fue el viejo quien me heredó su colección de revistas Mas Allá (la primer revista argentina de ciencia ficción, editada a mediados de los '50 y que él guardó -sin saberlo- para encender otra llamita en mi cabeza, que entró con estos tomos en el mundo de la ciencia ficción, que es también responsable de gran parte de las ideas que me llevaron a dedicarme a la programación.

El resto es historia, pero todo empezó con esos empujones iniciales de mi querido viejo, con quien ya no voy a poder charlar de nuestros interés comunes, y a quien sólo me queda extrañar.

Agiles 2011 en Buenos Aires - ¡tres días imperdibles en octubre!

Como todos los años desde 2008, se viene la conferencia latinoamericana de metodologías Ágiles.

Para quienes no están al tanto de la historia, todo empezó en Buenos Aires, Argentina en 2008 con un grupo de entusiastas que nos embarcamos en la locura de organizar un evento internacional, con gente viniendo desde muchos países de la región, y varios invitados especiales llegados desde USA y Europa.

La primer conferencia fue un éxito y al año siguiente se hizo en Florianopolis, Brasil, y el año pasado en Lima, Perú.

En su regreso a Buenos Aires, y con la experiencia de los últimos años, el equipo organizador ha logrado mejorar el proceso completo y hoy estamos orgullosos de poder abrir la registración con meses de anticipación, y teniendo ya confirmada la sede, los oradores principales y los primeros patrocinadores.

La conferencia este año durará tres días, del 11 al 13 de octubre, dentro de los que habrá una combinación de sesiones, talleres y open spaces.

La conferencia será en la Universidad de Palermo, en la Facultad de Ingeniería y Diseño, en Mario Bravo 1050 de la Capital Federal.

Tendremos el lujo de contar con dos oradores principales reconocidos internacionalmente (y hay más figuras intesadas que esperamos ir confirmando en las próximas semanas):

Jeff Patton es consultor independiente, docente y mentor ágil. En su sitio http://www.agileproductdesign.com/ hace foco en diseño centrado en el usuario y en la concepción del producto. Colaboró con Alistair Cockburn en el clásico libro Crystal Clear y es fundador y moderador del foro agile-usability en Yahoo, y ganó el premio Gordon Pask por su contribución al agilismo en 2007.

James Shore es co-autor del libro The Art of Agile Development editado por O'Reilly en 2007, y mantiene el blog del mismo nombre. Fue el primer ganador del premio Gordon Pask en 2005 y es uno de los entrenadores y presentadores ágiles más reconocidos por su visión que abarca el lado técnico tanto como el humano, de proyecto y negocios.

Ya está abierta la registración y los precios finales de la conferencia son muy económicos, más aún si se paga antes del 31 de agosto, que tienen aproximadamente un 20% de descuento.

Todos aquellos que tengan interés en proponer actividades, estén atentos porque en los próximos días se abrirá también la recepción de propuestas para las diferentes categorías.

Quienes tengan interés en colaborar patrocinando el evento, pueden descargar el documento de patrocinio que contiene las condiciones y datos de contacto.

Recursos gratuitos para empezar con Node.js

A través de un tweet de mi amigo Juancho Ladetto encontré este post de ReadWrite Hack comentando una series de recursos sobre Node.js.

Para los que no saben o no recuerdan de que se trata Node, hice una breve introducción en un post anterior, y los demás sabrán que es una de las tecnologías que me parece más prometedora entre las últimas apariciones, y creo que este año va a crecer muchísimo.

Uno de los recursos más interesantes es este libro (en progreso) de Tom Hughes-Croucher que O'Reilly, que puede leerse (en inglés) por ahora libremente en su versión previa (e incluso colaborar en la revisión).

El libro por ahora cubre los conceptos fundamentales, con buenas explicaciones incluyendo simpáticos dibujos como este:

También cubre las interfaces de programación principales como el EventEmitter, la sintáxis de Callbacks, servidores y clientes HTTP, peticiones GET, POST y PUT, el objeto ClientResponse y el uso de URLs, query strings, Streams de lectura, el FileSystem y Buffers.

Está iniciado también el capítulo cubriendo interfaces de ayuda, por ahora solo DNS, y el de documentación general que cubre varias clases, el depurador, marco de pruebas unitarias, sub-procesos, consola de comandos REPL, y mucho más (todo esto en formato de referencia).

Otro recurso interesante y en progreso es la guía de Felix (también en inglés), que cubre varias partes similares pero a distinta profundidad y con otro enfoque, y tiene una sección dedicada a "convencer al jefe" que apunta a resaltar las características principales de Node para poder explicarlo a otros.

Page Speed online: una nueva herramienta para medir el rendimiento de sitios web

Parte del desarrollo de sitios web de calidad es hacer un análisis correcto de su rendimiento, sobre todo desde temprano, utilizando recomendaciones y técnicas modernas para asegurar un sitio correctamente optimizado. Esto no quiere decir ir en contra de la famosa máxima de Donald Knuth, quien nos ensenó que "la optimización prematura es la causa de todos los males" en programación.

Cualquier sitio web público con una expectativa mínima de tráfico debería responder a una línea base para garantizar una buena experiencia a sus usuarios, y hoy día no necesitamos aplicar técnicas extravagantes o perder mucho tiempo para esto, sino más bien aplicar recursos estándares y sencillos, disponibles en todas las plataformas.

Entre las herramientas para realizar el análisis de rendimiento frecuentemente mencionamos la clásica Firebug (y su plugin YSlow) para Firefox, y Page Speed para Firefox o Chrome. Ambas son excelentes y complementarias, cada una con sus fortalezas, pero ahora Google aporta una alternativa más que puede ser útil en muchas circumstancias: Page Speed online.

A diferencia de las anteriores, en lugar de un plugin, este es un servicio en línea que realiza el mismo tipo de análisis, con lo que podemos ejecutarlo desde cualquier navegador, pero sobre todo puede orientar el análisis sobre navegadores desktop (corriendo en una computadora) como sobre navegadores móviles (sobre todo corriendo en smartphones), para los que incluye algunas reglas específicas como la de eliminar redirecciones en la página inicial que no puedan mantenerse en cache, o reducir la cantidad de Javascript durante la carga de la página. Estas son todas situaciones que no son tan problemáticas en otro ambiente, pero en un teléfono que tiene usualmente un ancho de banda y procesamiento limitados, hacen mucha diferencia.

Veamos un ejemplo. Realicé un análisis para navegadores desktop sobre un sitio popular como Twitter, ingresando la dirección:

Y el resultado dio 77 sobre 100 (bastante bueno). El detalle es el siguiente:

Prioridad alta: Estas son reglas que pueden generar mayor impacto en el rendimiento del sitio y que uno debería atacar inicialmente. En el caso de Twitter sólo queda en este nivel la regla: Combinar imágenes como sprites CSS.

Prioridad media: En el siguiente nivel las reglas son: entregar imágenes a escala, optimizar imágenes y minificar Javascript.

Prioridad baja: En este nivel ya hay unos cuantos más. Si quieren pueden ver el informe completo.

Para terminar ejecuto el mismo análisis para la versión móvil de Twitter:

... y: ¡Oh, sorpresa! me da 100/100. No es de extrañar que Twitter esté muy optimizado para su acceso desde móviles. Así que pruebo con otro servicio que tiene buena tradición en cuando a rendimiento (es donde se empezó a trabajar en estas áreas): http://news.yahoo.com/

El resultado para móviles es de 79/100, que es bastante bueno.

No hay reglas de alta prioridad para atacar, y en las de media, ambas son muy específicas para teléfonos: diferir la interpretación de Javascript y hacer que las redirecciones de la página de inicio puedan mantenerse en cache.

Como siempre, lo importante de estos análisis es leer con atención la información acerca de cada regla, entender de qué se trata y que prácticas tenemos que adoptar de manera permanente para que no vuelva a producirse.