lunes, 31 de enero de 2011

Microsoft Web Platform Installer

Web Platform Installer

Una de las quejas recurrentes al trabajar con el stack web de Microsoft era siempre la dificulta de instalar los componentes necesarios, no solamente en el puesto de desarrollo, donde con un poco de tiempo y paciencia se logra, sino en el servidor de producción, donde generalmente el tiempo y la disponibilidad no es tan abundante.

Para solucionar este tema, desde hace tiempo se liberó esta herramienta: el Web Platform Installer, conocido familiarmente como Web PI, que actualmente ya se encuentra en su versión 3.0.

Como Microsoft promociona en el sitio principal, este instalador tiene varias características interesantes:

  • Es gratuito
  • Es pequeño (2 MB)
  • Es inteligente (bueno, al menos entiende algunas dependencias)
  • Está actualizado (siempre propone las últimas versiones de los componentes)
  • Está disponible en 9 lenguajes (incluido español, por supuesto)
  • Instala muchísimas aplicaciones de diversos orígenes (incluyendo IIS, SQL Express, .NET, pero también aplicaciones PHP como Umbraco, Drupal, o mi amigo Moodle). Hay disponible una galería de aplicaciones.

Además de componentes de infraestructura, Web PI también permite instalar herramientas de desarrollo como Visual Studio Express y frameworks como ASP.NET MVC y otros.

Una novedad interesante, e imprescindible desde mi punto de vista, es que ahora toda la funcionalidad se puede acceder por línea de comando, incluyendo cierto control de comportamientos algo molestos de la plataforma Windows que al menos se minimizan un poco con esto: aprobación de acuerdos de licencia y necesidad de booteos.

Que quede claro: hace falta seguir aprobando la licencia pero podemos indicar en el script que la acepte automáticamente, y hay muchos componentes que siguen requiriendo re-bootear la máquina, pero al menos podemos forzar a que no lo haga en cada producto, o no lo haga en todo el proceso. La instalación final se completará en el siguiente boot (sea manual o por script) y Web PI se encarga de resolver este tema solo.

 

viernes, 28 de enero de 2011

Zapatero a tus zapatos; con Ruby

Shoes

Shoes es un pequeño entorno multi-plataforma para escribir aplicaciones gráficas en Ruby.

El objetivo de Shoes no es generar aplicaciones de muy alta complejidad, sino más bien ser una plataforma para desarrollar utilidades o fundamentalmente, aprender y practicar. Sin embargo, a veces es sorprendente el nivel de cosas que se pueden llegar a lograr.

Shoes está basado en Ruby y puede utilizarse en Windows, Mac OS X o Linux, y el proyecto fue iniciado originalmente por _why, una celebridad del mundo Ruby que desapareció de la web en agosto de 2009, sin que se sepa más de él, cerrando todas sus cuentas, pero dejó además de Shoes, una serie de productos notables como la clásica "Why's (poignant) Guide to Ruby", realmente un libro completo sobre Ruby pero completamente ilustrado y muy divertido, licenciado bajo Creative Commons (libro completo en pdf comprimido como zip).

Pero volvamos a Shoes. Así describía _why algunas de las cosas que se pueden hacer con esta herramienta, en la guía original "Nobody Knows Shoes":

Nobody Knows Shoes

Y veamos algunos ejemplos en la práctica, con un poco de código y capturas de pantalla, empezando con algo similar al canónico "Hola, Mundo":

Shoes.app :width => 300, :height => 200 do
2   button("Click me!") { alert("Good job.") }
3 end

Da por resultado lo siguiente, en Windows, Linux y OS X, respectivamente:

GoodJob WinGoodJob Linux
GoodJob OS X

Y un ejemplo un poco más complicado, pero donde pueden ver lo sencillo y práctico de este entorno:

#
# Shoes Clock by Thomas Bell
# posted to the Shoes mailing list on 04 Dec 2007
#
Shoes.app :height => 260, :width => 250 do
  @radius, @centerx, @centery = 90, 126, 140
  animate(8) do
    @time = Time.now
    clear do
      draw_background
      stack do
        background black
        para @time.strftime("%a"),
          span(@time.strftime(" %b %d, %Y "), :stroke => "#ccc"),
          strong(@time.strftime("%I:%M"), :stroke => white),
          @time.strftime(".%S"), :align => "center", :stroke => "#666",
            :margin => 4
      end
      clock_hand @time.sec + (@time.usec * 0.000001),2,30,red
      clock_hand @time.min + (@time.sec / 60.0),5
      clock_hand @time.hour + (@time.min / 60.0),8,6
    end
  end
  def draw_background
    background rgb(230, 240, 200)

    fill white
    stroke black
    strokewidth 4
    oval @centerx - 102, @centery - 102, 204, 204

    fill black
    nostroke
    oval @centerx - 5, @centery - 5, 10, 10

    stroke black
    strokewidth 1
    line(@centerx, @centery - 102, @centerx, @centery - 95)
    line(@centerx - 102, @centery, @centerx - 95, @centery)
    line(@centerx + 95, @centery, @centerx + 102, @centery)
    line(@centerx, @centery + 95, @centerx, @centery + 102)
  end
  def clock_hand(time, sw, unit=30, color=black)
    radius_local = unit == 30 ? @radius : @radius - 15
    _x = radius_local * Math.sin( time * Math::PI / unit )
    _y = radius_local * Math.cos( time * Math::PI / unit )
    stroke color
    strokewidth sw
    line(@centerx, @centery, @centerx + _x, @centery - _y)
  end
end

Todo esto da por resultado este coqueto reloj analógico, que obviamente, funciona:

Shoes Clock

Espero haber generado interés suficiente. La mejor manera de familiarizarse con Shoes (y probablemente con Ruby, para quien no lo hizo) es descargarlo y empezar a divertirse.

martes, 25 de enero de 2011

Code Katas - la práctica hace al Maestro (videos)

Kata.jpg

Tomando como inspiración la forma en que los músicos ensayan para mejorar su técnica, o más directamente la manera en que se realizan las prácticas en las artes marciales, efectuando ejercicios repetitivos hasta dominar por completo ciertos movimientos, lo que permite empezar a componerlos, Dave Thomas (uno de los Pragmatic Programmers), comenzó a popularizar el concepto de Code Katas. Para quienes quieran saber la historia completa de la génesis Dave la cuenta completa en este post.

Con el tiempo, el concepto de Code Kata trascendió a Dave y fue adoptado por mucha gente dentro de la comunidad, con variantes en la manera de encararlo, pero compartiendo una intención común.

En forma simplificada, la idea de un Kata de código es similar a su predecesor en Karate (y no es exactamente lo mismo, pero Dave tomó la idea general, no intentó que sea un calco de las artes marciales). Se trata de realizar prácticas frecuentemente sobre una serie de movimientos (en código, ejercicios determinados).

Esta idea de la práctica constante tiene que ver con ideas como las de Peter Norvig en su clásico "Aprende a programar en 10 años" (traducción al español de Carlos Rueda).

Uno de los más clásicos es la calculadora de strings. La idea es hacer un programa que resuelva expresiones como "42 * 8" o "(66 / 3) -7". El ejercicio implica un mínimo de parsing para separar los operadores y operandos, y manejar un stack para los paréntesis. Obviamente no hay una respuesta única, e incluso la resolución puede variar mucho si el ejercicio se resuelve en Java, en Haskell o en Cobol.

La diferencia con realizar el ejercicio una sola vez, es que en los Katas vamos a resolver ese mismo ejercicio (y otros) muchas veces. Es realmente como ensayar un tema musical. Cada vez sale mejor, pero todas las veces la experiencia es levemente diferente. También podemos aprovechar la familiaridad con el ejercicio en si para probar diferentes técnicas.

Por ejemplo, podemos tomar otro Kata, como el clásico FizzBuzz, que en varios lados utilizan como primer filtro en las entrevistas a programadores, y realizarlo la primera vez a los tumbos, luego utilizando pruebas unitarias, luego con TDD, luego sin usar el mouse, luego cambiar de lenguaje, etc. Este es un ejercicio bastante corto que permite incluso ser resuelto varias veces seguidas durante el lapso de una hora o dos.

Extrañamente, mucha gente no encuentra sentido a este tipo de práctica, y sin embargo puede pasar horas y horas tratando de tocar Escalera al Cielo de Led Zeppelin (sin ser buen guitarrista, para empezar). Lo importante es poner el mismo tipo de intención en estos ejercicios, tratar de mejorar nuestra técnica, optimizar el flujo de trabajo de nuestra IDE o editor, la legibilidad del código, etc.

Definitivamente, quienes trabajamos en esta industria bastante tiempo sabemos que los años pasados de experiencia no equivalen a "experiencia valiosa". Este tipo de actividades nos mantiene afinados. Y afortunadamente hay entusiastas que nos acompañan, como en CodingKata.org o la reciente iniciativa en español 12 meses, 12 katas.

Casualmente de este último les comparto un ejemplo en video, de la calculadora de strings en Ruby (utilizando RSpec para las especificaciones/pruebas) por Eric Minio. Recuerden, la solución de Eric no es más que una de muchas posibles. La gracia es ver cómo lo hace él y hacerlo nosotros con nuestras propias ideas, técnicas y herramientas.

Noten que los katas no necesitan ser ejercicios menores y simples. Como comprobación de la hipótesis del título de este post, baste ver como el Maestro Angel "Java" López se ejercita continuamente con sus particulares katas (compiladores, intérpretes, utilitarios), todos disponibles en su repositorio de katas en Google Code.

Como comparación final, les dejo otra versión del Kata de la calculadora de Strings, pero escrita en Clojure por Tom Crayford.

String Calculator Kata from Tom Crayford on Vimeo.

lunes, 24 de enero de 2011

HTML5 para todos

HTML5 logoEl tema está más caliente que nunca, y estuve charlando en estos días con diferentes personas que no han llegado a familiarizarse todavía con los conceptos detrás de este conjunto de tecnologías, por lo que me parece apropiado hacer una compilación de recursos sobre el tema, extendiendo un poco lo cubierto en el post sobre el logo de HTML5.

A continuación dejo una serie de recursos (en inglés) para profundizar sobre varias de las tecnologías que forman parte de este estándar en constante evolución, que a pesar de no estar completamente especificado, está siendo utilizado masivamente en producción.

Demos

Lo primero que puede ser útil es ver algunos ejemplos de las distintas capacidades, así que van algunos recursos para familiarizarse y entender un poco más lo que hay disponible. En casi todos los casos está aclarado, pero vale reiterarlo: estos ejemplos funcionan bien, mal o nada según el browser con que se prueben. Idealmente, conviene tener más de uno a mano para entender las diferencias. Y también es bueno ver qué cosas funcionan en todos o casi todos.

  • HTML 5 Demos and Examples contiene demos duras de funcionalidad específicas por API. Son técnicas e incluyen código simple para entender cómo se usan, pero no son especialmente atractivas visualmente.
  • 48 Excellent HTML5 demos incluye más demos vistosas. Están recopiladas de distintos orígenes y  no siempre tienen mucho detalles sobre las técnicas subyacentes, pero sirven para darse idea de las posibilidades.
  • HTML5 Form Demo es un único ejemplo que muestra concisamente el mecanismo de validaciones en formularios y los recursos gráficos asociados. Una buena descripción del API se encuentra en esta página de Mozilla.
  • Los Slides de Google que son usados en casi todas sus presentaciones, tienen un montón de demos que apuntan sobre todo al soporte de Chrome, pero la mayoría funcionan en FireFox, Safari, Opera e incluso en IE 9 Beta. Lo interesante es que la presentación completa está armada en HTML5 y las explicaciones son muy detalladas.

Ejemplos, Plantillas

  • html5bolerplate es una plantilla muy completa que permite utilizar todos los recursos comunes de HTML5 en la mayoría de los browsers (¡incluyendo IE6!). Además, utiliza las mejores técnicas de caching y compresión para máxima eficiencia, buenas prácticas de configuración del sitio (para Apache, IIS, ngnix, etc), optimizaciones para navegadores móviles, y mucho más.
  • Para quienes se asusten con la plantilla anterior (por la inmensa cantidad de cosas que contempla), Easy HTML5 Template o HTML5 Reset son versiones reducidas, menos ambiciosas, que pueden servir como punto de partida.

Guías y Cartillas

 

 

jueves, 20 de enero de 2011

Raros Lenguajes Nuevos: CoffeeScript

CoffeeScript

CoffeeScript es un lenguaje que compila a JavaScript, y mantiene una premisa fundamental: sigue siendo JavaScript.

El código es compilado a su equivalente, y es posible utilizar cualquier librería o extensión como en el ambiente original. El código final generado es prolijo y entendible, pasa las validaciones de JavaScript Lint y funciona en cualquier motor de JavaScript.

Lo que CoffeeScript aporta es una sintaxis simplificada, inspirada en Ruby y Python, despojada de llaves y puntos y comas, bastante más legible pero con exactamente el mismo poder y características del JavaScript tradicional.

Veamos algunos ejemplos:

# Asignación:
number   = 42
opposite = true
# Condiciones:
number = -42 if opposite

Esto genera el siguiente JavaScript:

var number, opposite;
number = 42;
opposite = true;
if (opposite) {
number = -42;
}

Y aunque estos ejemplos suenan triviales, ya pueden notarse algunas abreviaturas importantes. Pero veamos un ejemplo más extremo, que utiliza declaración de funciones, espacios de nombre y comprensión de arrays:

# Declaración de funciones
square = (x) -> x * x

# Declaración de un array:
list = [1, 2, 3, 4, 5]

# Funciones dentro de un espacio de nombres:
math =
  root:   Math.sqrt
  square: square
  cube:   (x) -> x * square x

# Comprensión de Arrays: cubes = (math.cube num for num in list)

Y su equivalente en JavaScript:

var cubes, list, math, num, square;
var __slice = Array.prototype.slice;

square = function(x) {
  return x * x;
};

list = [1, 2, 3, 4, 5];

math = {
  root: Math.sqrt,
  square: square,
  cube: function(x) {
    return x * square(x);
  }
};

cubes = (function() {
  var _i, _len, _results;
  _results = [];
  for (_i = 0, _len = list.length; _i < _len; _i++) {
    num = list[_i];
    _results.push(math.cube(num));
  }
  return _results;
})();

¿No es notoriamente más clara la versión en CoffeeScript?

La sintaxis completa y referencia está disponible en línea.

¿Cómo funciona? El compilador está escrito en CoffeeScript (en la mejor tradición geek) utilizando Jison Parser Generator. La versión de línea de comando funciona sobre Node.js, aunque el compilador en si puede correr en cualquier motor de JavaScript.

Algo muy interesante es que cualquiera que quiera jugar un poco no necesita instalar nada. Simplemente puede ir al sitio de CoffeeScript dentro de GitHub y elegir “Try CoffeeScript” en el menú superior para acceder a un editor en línea que permite escribir código CoffeeScript del lado izquierdo y va mostrando cómo se compila (en tiempo real, letra por letra) en JavaScript, como se ve en la figura:

 

Try CoffeeScript

martes, 18 de enero de 2011

HTML 5 ya tiene logotipo oficial

HTML 5

Si, el W3C lanzó el logotipo oficial de HTML 5 como parte de la campaña para impulsar el standard.

El logo no es solo una imagen suelta. Hay detrás una serie de guías de uso, ya se han hecho stickers y remeras, y además está publicado bajo una licencia Creative Commons que permite flexibilidad al utilizarlo.

Entre otras características, el logo puede ser acompañado en una placa que puede agregarse a cualquier sitio para detallar cada una de las tecnologías del estándar que están utilizadas en esa aplicación.

Este ejemplo muestra todas las características habilitadas (los íconos de cada una son parte del paquete de diseño que acompaña el logo):

HTML5 Powered with Connectivity / Realtime, CSS3 / Styling, Device Access, Graphics, 3D & Effects, Multimedia, Performance & Integration, Semantics, and Offline & Storage

Notarán si pasan el mouse sobre la imagen la lista de las tecnologías soportadas. Los íconos corresponden a:

HTML5_Connectivity
Conectividad: hace referencia a Web Sockets y Eventos enviados desde el servidor, que habilitan un estilo de comunicación "push" (donde el browser cliente no necesita timers para ir a buscar novedades, sino que puede recibirlas) o entre pares (browser a browser, por ejemplo).

HTML5_Styling
CSS3
: extiende los estilos para soportar transiciones y efectos, tipografías y muchos otros detalles de presentación.

HTML5_Device_Access
Acceso a dispositivos
: implica acceso a características específicas del hardware debajo del browser. El ejemplo actual de implementación es el Geo-posicionamiento (el API abstrae esta funcionalidad de la manera en que el dispositivo la resuelve -con una combinación de GPS, WiFi, señales de red celular, etc).

HTML5_3D_Effects
3D, Gráficos y Efectos: cubren características como SVG, Canvas, WebGL y extensiones 3D de CSS3.

HTML5_MultiMedia
Multimedia: incluye los nuevos tipos de objetos que soportan audio y video.

HTML5_Performance
Rendimiento e Integración: refiere a la nueva funcionalidad de Web Workers, que permiten ejecutar scripts en paralelo, y XMLHttpRequest nivel 2, que mejora el componente original con la capacidad de manejar peticiones desde orígenes cruzados, agrega eventos de progreso y manejo de streams para envío y recepción.

HTML5_Semantics
Semántica
: enriquece el contenido al darle significado a través de nuevos tags, RDFa, micro-data y micro-formatos.

HTML5_Offline_Storage
Fuera de línea y Almacenamiento
: abarca el soporte para operar en forma desconectada a través de las APIs de App Cache, Local Sotrage, Indexed DB y File.

 

Esperemos ver el logo en uso frecuente hasta que estas características sean ubicuas y se transforme en irrelevante.

lunes, 17 de enero de 2011

Video: Avalancha de lanzamientos desde Microsoft

WebMatrix

El Web Platform & Tools Content Team de Microsoft (hasta donde recuerdo, el grupo en el que está Scott Hanselman) acaba de liberar una cantidad impresionante de productos:

El hecho de que haya salido todo junto no es casualidad: todos estos productos están relacionados de alguna manera, ya que en principio son todos piezas de la nueva estrategia de Microsoft para el desarrollo web, caracterizada por romper un poco los esquemas tradicionales de la compañía. Por ejemplo, muchos de los componentes están liberados como Open Source, y otros son gratuitos, y en líneas generales todos son bastante livianos (mucho más de lo habitual en el mundo Microsoft al menos).

Esta renovada plataforma responde indudablemente al intento de Microsoft de competir con el ambiente más popular en el desarrollo web que va desde PHP hasta Ruby on Rails, e incluso abarca parte de este espacio, como veremos.

Veamos cada componente en un poco más de detalle. Como hay mucha información de Microsoft al respecto, lo que leerán es mi interpretación personal sobre ellos, tratando de relacionarlos con equivalentes en otras plataformas con el objetivo de entender rápidamente el propósito de cada pieza, sin entrar en comparaciones sobre si una es mejor que otra. En principio, es difícil comparar plataformas disimiles y componentes aislados.

ASP.NET MVC es un framework open source basado en el ya antiguo patrón MVC (fue postulado originalmente por Trygve Reenskaug entre 1978/79 en Xerox) y mayormente ignorado por Microsoft en su aproximación a la web, mientras se lo adoptaba en otros ámbitos en frameworks como Struts en Java, Joomla/Drupal en PHP, Django en Python y Rails en Ruby.

Esta versión de MVC incorpora algunas novedades como un nuevo motor para las vistas, Razor, que tiene una sintaxis muy suscinta y clara para mezclar código con HTML con un mínimo de interferencia. También mejoraron mucho la limpieza del JavaScript que integran del lado cliente al evitar scripts inline y usar en cambio anotaciones de HTML 5 que son manejadas por JQuery y jQuery.unobtrusive-ajax, con lo que se pueden realizar validaciones y otras tareas del lado cliente.

Otro pilar de este framework es la extensibilidad, ya que se puede cambiar fácilmente el motor de vistas, soporta montones de frameworks de testing, alternativas para el modelo y su persistencia, y en esta nueva versión incluso mejora el mecanismo de inyección de dependencias, de modo de poder usar el contenedor que más nos guste para intercambiar cualquiera de las piezas.

NuGet es un administrador de paquetes que intenta acercar la funcionalidad de las gem de Ruby al mundo .NET. Todavía es relativamente nuevo, pero comparado con el proceso anterior de búsqueda e inclusión manual de las dependencias es un avance enorme, y seguramente va a facilitar mucho el uso de componentes externos. El proyecto es open source y es mantenido por Microsoft y miembros externos.

IIS Express es una versión gratuita de desarrollo del servidor web, mucho más liviana que el servicio completo, y con la posibilidad de utilizarlo y configurarlo sin requerir privilegios de administrador, algo que tradicionalmente generó muchísimos problemas en equipos dentro de un entorno corporativo seguro.

SQL Server Compact 4 es una versión embebida y gratuita de SQL Server. Algo similar a un SQLite. Los binarios se copian directamente dentro de la aplicación y la base de datos corre dentro del mismo proceso, con lo que no es necesaria ninguna instalación. Por supuesto este servidor no tiene las características de escala que sus hermanos mayores, pero es más que suficiente para una gran cantidad de aplicaciones, y no tiene ningún tipo de restricción de uso en su licencia.

Web Deploy y el Web Farm Framework, como sus nombres lo indican, facilitan el proceso de despliegue y actualización de aplicaciones web en servidores únicos o compuestos en granja. Ambos componentes son gratuitos.

Orchard es un sistema de administración de contenido y blogs open source, basado en MVC 3, utilizando Razor y SQL Compact por omisión. Después de un intento similar poco prolijo y muy criticado (llamado Oxite), Orchard estuvo mucho más cuidado en todo sentido, y aunque por supuesto hay críticas, el consenso es que esta es una aplicación de referencia mucho más valiosa.

Y finalmente, WebMatrix es una herramienta gratuita de desarrollo de aplicaciones web que soporta una cantidad bastante variada de tecnologías en base a plantillas, incluyendo cosas dentro y fuera del mundo Microsoft (aunque corriendo en Windows), como ScrewTurn, Umbraco, DotNetNuke, Orchard, Blogengine.net,WordPress, Drupal y Joomla. Por debajo, WebMatrix incluye IIS Express y SQL Compact, brindando un entorno completo.

Algo interesante que tiene WebMatrix es una cantidad creciente de helpers para integrar muchísimos servicios servicios populares hoy día en la web, como Bit.ly, Facebook, EventBrite, FourSquare, OData, Twitter, UserVoice y muchísimos más.

 

Finalmente, otro elemento importante de todo este combo es la cantidad impresionante de documentación disponible. Basta como muestre este listado de recursos.

Para cerrar, les dejo este video presentando WebMatrix dentro de CodeMash 2.0.1.1(si tienen problemas viendo el video, prueben en la página original en Channel 9):

viernes, 14 de enero de 2011

Video: ¿Existe la mejor forma de probar?

Agiles

El martes pasado se realizó la reunión mensual de Agiles @ Buenos Aires, organizada por la comunidad local Agiles.org. Para estar al tanto de estas actividades conviene suscribirse a la lista de correo Agiles Argentina.

La mecánica de estas reuniones es que tradicionalmente al cierre de cada una se proponen y votan los temas para la próxima, teniendo en cuenta temas que estaban pendientes en una especie de backlog informal.

Esta vez el tema central fue el testing desde un punto de vista ágil, iniciando con la presentación de Juan Gabardini titulada "¿Existe la mejor forma de probar?". En la sesión Juan recorre su experiencia personal como desarrollador volcado a tareas más ligadas a control de calidad (QA), recorriendo el espectro desde las pruebas manuales hasta las técnicas de automatización más sofisticadas, y reflexionando sobre el valor de cada variante y sus combinaciones.

La segunda mitad del evento fue una serie de preguntas, respuestas y debate a raíz de la presentación, que fue muy interesante pero es difícil de compartir en video.

Afortunadamente, si tenemos grabada la presentación de Juan, y para todos aquellos que tengan dudas o temas a debatir, creo que lo mejor puede ser plantearlos en la lista, donde tanto Juan como otros agilistas pueden aportar sus opiniones.

 

 

 

jueves, 13 de enero de 2011

YUI 3.3.0 - Nueva versión de la librería de Yahoo!

YUI Autocomplete

Recién salida del horno, la versión 3.3.0 de YUI (Yahoo! User Interface) trae unas cuantas novedades para pulir la interfaz de las aplicaciones web sin costo del lado servidor.

Entre las principales características:

  • Soporte para FireFox 4, Internet Explorer 9 y Android 2.2.
  • Abstracciones más dulces para manipulación de nodos, como show y hide para controlar la visibilidad de nodos completos (o listas de nodos), o wrap, unwrap y otros métodos.
  • Un widget para auto-completar entradas de texto (como se ve en la figura a la derecha).
  • Gráficos estadísticos (usando una combinación de SVG, Canvas y VML).
  • Un widget para tablas de datos, incluyendo paginado y ordenamiento dinámico de manera extensible. Al pie, los interesados pueden ver este video de Tilo Mitra presentando este componente en el evento YUIConf 2010.
  • Otro widget para incluir diales de valores (similares a una perilla de volumen) con una granularidad muy fina.
  • Y.ResizeUtilidad de resize, que activa la posibilidad de cambiar el tamaño de elementos en el browser utilizando los típicos ganchos en las esquinas y lados (ver imagen a la derecha).

Esta librería sigue creciendo y agregando mucha funcionalidad interesante. Mientras escribo esto estoy charlando con Juampi que es más fanático de JQuery (admito que yo también). Sin embargo, no hay que perder de vista que el mundo de Javascript es hospitalario y cuida la convivencia con el uso de recursos como espacios de nombres y pruebas extensivas con elementos externos.

Para quienes quieran aprovechar lo mejor de ambos lados, recomiendo pegar una leída a especialmente a la documentación de JQuery en relación a su uso con otras librerías.

Les dejo el video sobre las tablas de datos (en inglés):

 

miércoles, 12 de enero de 2011

Curso Certified ScrumDeveloper (CSD) Track - Verano 2011

Kleer

Hoy dedico el post a un pequeño aviso, porque se que hay mucha gente interesada en capacitación sobre Scrum, y en particular estos cursos tienen que ver con un área que me parece muy importante y no siempre bien cubierta, que es la parte técnica o de ingeniería que se requiere para poder mantener la calidad iteración tras iteración.

Esta serie de cursos que organiza Kleer (la única empresa en Argentina certificada por la Scrum Alliance para dar estos cursos), tiene el siguiente temario:

* Los conceptos básicos, valores y principios de la agilidad y Scrum 
* Técnicas de análisis de procesos e identificación de historias de usuario 
* Técnicas de estimación y planificación con Scrum 
* La creación de historias de usuario que den lugar a desarrollos evolutivos 
* La identificación y automatización de sus pruebas de aceptación 
* La comunicación con el equipo mediante integración continua 
* Técnicas de diseño y desarrollo dirigido por pruebas (TDD) 
* La utilización de taskboards y métricas ágiles 

El track está orientado a: 



CSD en acción

* Gerentes de Proyecto con formación en gestión 
* Gerentes de Proyecto con background técnico 
* Gerentes de Desarrollo 
* Líderes Técnico 
* Arquitectos de Sistemas 
* Desarrollador de Software

 

El programa completo incluye tres cursos independientes:

Curso de Introducción a Scrum

Duración: 8hs.

Fecha de Dictado: 21 de Febrero de 9 a 18hs

Lugar: Microcentro, Buenos Aires

Curso de Estimación y Planificación con Scrum

Duración: 8hs.

Fecha de Dictado: 22 de Febrero de 9 a 18hs

Lugar: Microcentro, Buenos Aires

Curso de Desarrollo Ágil de Software en Scrum

Duración: 24hs.

Fecha de Dictado: Del 23 al 25 de Febrero de 9 a 18hs

Lugar: Microcentro, Buenos Aires

Para consultas: entrenamos@kleer.la

También se puede ver  el calendario completo de Kleer o ver las fotos de los cursos anteriores en su página de Facebook.

 

martes, 11 de enero de 2011

Json.Net 4.0 acerca el lado dinámico y estático de las aplicaciones web

Json

Json.Net es una librería de alto rendimiento para manejar el protocolos Json (JavaScript Object Notation) desde .NET.

Json es el mecanismo de comunicación más utilizado hoy día en aplicaciones web modernas. La revolución inicial de AJAX (Asynchronous JavasScript And XML) implicaba, como su nombre lo indica, intercambiar XML desde el browser y el servidor, manipulando el DOM de las páginas para refrescar datos, en lugar de volver a traer el HTML completo. Desde hace tiempo esto dejó de hacerse serializando a XML, pasando en cambio a Json porque es más compacto, lo que implica menos tráfico, pero también porque es muchísimo más JSON.parse (en JavaScript puro) o $.getJSON (en JQuery).

Sin embargo, volviendo a .NET, tradicionalmente la convivencia entre el mundo estático y el paradigma eminentemente dinámico que propone Json no fue sencilla. Existe dentro del framework el espacio System.Web.Script.Serialization que contiene un JavaScriptSerializer, pero utilizarlo es una tarea ardua y bastante propensa a errores.

Entre las alternativas abiertas, Json.Net es una de las más populares, y en su reciente versión 4.0 (release 1), aprovecha las nuevas características dinámicas del .NET Framework 4. Más que ninguna otra cosa, el uso de esta librería se simplificó enormemente a partir de aprovechar el nuevo tipo dynamic en .NET (que irónicamente, es un tipo estático más), y el agregado de LINQ to Json.

Veamos el uso de Json.Net con tipos dynamic:


dynamic value = new DynamicDictionary();

value.Name = "Juan Perez";
value.Enabled = true;
value.Roles = new[] {"Admin", "User"};

string json = JsonConvert.SerializeObject(value, Formatting.Indented);
// {
// "Name": "Juan Perez",
// "Enabled": true,
// "Roles": [
// "Admin",
// "User"
// ]
// }

¿No es elegante? Y mucho más sencillo que cualquier cosa tradicionalmente en .NET. Consumamos ahora el Json, a la inversa que en el ejemplo anterior:


dynamic newValue = JsonConvert.DeserializeObject(json);

string role = newValue.Roles[0];
// Admin

Finalmente, LINQ to Json permite (entre otras cosas) realizar consultas directamente sobre un resultado Json de manera simple y eficiente, como en este ejemplo:


var categories =
from c in rss["channel"]["item"].Children()["category"].Values()
group c by c into g
orderby g.Count() descending
select new { Category = g.Key, Count = g.Count() };

foreach (var c in categories)
{
Console.WriteLine(c.Category + " - Count: " + c.Count);
}

Algunas otras características de la nueva versión incluyen mejoras en la serialización binaria BSon, Json Schema, e inminentemente estará actualizado el paquete NuGet para instalar esta nueva versión desde Visual Studio directamente o desde la línea de comandos, manejando todas las dependencias que hubiese.

 

lunes, 10 de enero de 2011

Pycon 2011 - Del 9 al 17 de marzo en Atlanta, USA

PyCon 2011

La conferencia internacional de la comunidad Python de este año llega dentro de poco, a principio de marzo.

Llego tarde con el aviso, pero como siempre, la comunidad apoya financieramente a quienes quieren participar (y tienen buenas razones) pero no cuentan con la capacidad de costearse el pasaje o alojamiento.  Lamentablemente la presentación para solicitar ayuda financiera cerró a principio de este año, pero ténganlo en cuenta para los próximos años, porque al menos con una ayuda parcial muchos pueden llegar a tener la oportunidad.

Ya está disponible el cronograma completo de las charlas, y para quienes no puedan ir (imagino que la gran mayoría de los que están leyendo esto, incluyéndome a mi), recuerden que en general quedan los videos de toda la conferencia, como los del año pasado.

Como muestra para quien no quiere leer toda la lista, seleccioné las charlas que me parecieron más interesantes (a mi, obviamente):

Para quienes quieran seguir de cerca más detalles sobre la conferencia, pueden seguir su blog.

Y si algún lector asiduo de Code & Beyond asiste y tiene ganas de compartir notas con nosotros, basta con contactarme.

viernes, 7 de enero de 2011

Raros Lenguajes Nuevos: Scotch

Scotch

Siguiendo con la investigación sobre lenguajes experimentales o novedosos, hoy les presento Scotch, una creación de Ben Morris.

Ben empezó este proyecto de lenguaje como un ejercicio en Haskell, pero se entusiasmó con el resultado y sigue adelante, después de haberlo dejado abierto en GitHub para contribuciones de cualquiera.

Scotch es un lenguaje funcional que trata de mantener una sintaxis minimalista y expresiva, y agrega algunas características particulares a gusto de su creador:

La asignación es siempre no estricta (lazy), de manera que si definimos "a = b", no estamos pasando valores, sino asignando una expresión. Si luego decimos que "b = 42", al inspeccionar el resultado de "a", se va a evaluar la secuencia y obtendremos 42.

A diferencia de Haskell mismo, Scotch no es puro, y se pueden definir variables que mantengan estado, por lo que no queda libres de efectos colaterales como en lenguajes funcionales puros; también es débilmente tipado, lo que implica que podemos sumar números y strings, por ejemplo, y en lugar de dar error hace conversiones implícitas (siempre que pueda).

Otra característica interesante es la resolución implícita en base a reconocimiento de patrones. Por ejemplo, para definir una función que calcule el factorial de un número, se hacen dos definiciones, una genérica y una específica:

fact(n) = n * fact(n-1)
fact(0) = 1

La primera línea es la definición recursiva clásica, pero por si sola tiene el problema de que nunca terminaría, por lo que se puede definir el caso particular para cuando sea llamada con 0, de manera que en lugar de seguir llamándose a sí misma devuelva 1.

Casi toda la librería de clases está basada en este mecanismo, utilizando recursividad de cabeza y cola (head/tail) y utilizando patrones para manejar los casos límites donde debe cortarse la recursión.

Como casi todos los lenguajes funcionales, permite aplicación parcial y currying, como en este ejemplo:

apply(f, x) = f(x)
add(x, y) = x + y
apply(add(10), 20)

Aquí "apply" se define como la ejecución de una función que recibirá "x" como parámetro. La función "add" recibe dos parámetros y los suma, pero podemos aplicarla parcialmente como en el caso final, utilizando "apply".

También tiene soporte para hilos de ejecución livianos (lightweight threads), o sea que no son hilos reales del sistema operativo, sino implementados por el lenguaje mismo (en este caso utiliza los que provee Haskell).

Finalmente, el autor agregó Tipos de Datos Algebraicos (ADTs) que son como objetos livianos sin definición de clase, y funciones anónimas (lambdas).

La gracia principal de ste intérprete es que la implementación es muy pequeña y es un buen ejercicio tanto de implementación de un lenguaje como de Haskell mismo.

jueves, 6 de enero de 2011

Videos: Previews de Surface 2.0 y Android 3.0 (Honeycomb)

CES 2011

Durante la CES (la conferencia anual de electrónica para consumidores) que arrancó ayer, hubo unos cuantos anuncios ya, y algunas novedades ya dan vueltas por la red.

Microsoft pesentó la segunda versión de su dispositivo Surface, que ahora es muchísimo más fino ya que no usa más cámaras internas para capturar lo se apoya sobre la pantalla, sino que usa una tecnología en la que cada pixel es un sensor independiente. Esto permite usarlo no sólo como mesa, sino también como kiosko, más parecido a un televisor.

Google hara varios anuncios también, y ya tenemos al menos un video que muestra algunas características de la próxima versión de Android, que notarán orientado a mejorar la experiencia en tabletas además de teléfonos. Es interesante notar que algunas cosas como Maps en 3D y StreetView ya están disponibles hoy, aunque no con la misma velocidad que en el dispositivo del video.

Les dejo los videos de Surface y Android para que disfruten e imaginen aplicaciones:

 

miércoles, 5 de enero de 2011

Probando aplicaciones web con Zombie.js

http://www.flickr.com/photos/tohoscope/5086711384/Probar aplicaciones web modernas, con mucho scripting del lado cliente, es cada vez más complejo. El hecho de que la interfaz de usuario cambie dependiendo de las interacciones sin necesidad de pasar por el servidor genera la necesidad de realizar pruebas sobre el lado cliente.

El problema de esto es que la mayor parte de las herramientas para efectuar este tipo de pruebas requiere de una instancia de un browser real, lo que genera una dependencia fuerte y sobre todo, implica que cada prueba tarde más porque un browser demora un montón de tiempo en cargar y dibujar los elementos y tiene en cuenta montones de cosas que en realidad no necesitamos en la mayoría de los escenarios para hacer pruebas automatizadas.

Zombie.js se llama así porque es un entorno de prueba headless (sin cabeza; en realidad sin browser), y es muy rápido, además de brindar un API muy cómoda para escribir las pruebas.

La plataforma hace uso nuevamente de las ventajas de Node.js (más detalles en un post anterior) para recrear el entorno de un browser, incluyendo el DOM y características de HTML5, pero sin la necesidad de dibujar realmente nada, lo que le permite alcanzar velocidades totalmente diferentes.

Para lograr este entorno, Zombie combina varias librerías abiertas como JSDOM para emular el DOM, HTML5 para parsing, Sizzle para los selectores CSS y AJAXSLT para el soporte a XPath. Y el proyecto a su vez, también está abierto a quien quiera meter mano, alojado en GitHub.

Veamos un brevísimo ejemplo de cómo instanciar el entorno de un browser, navegar a una página, identificarse y verificar que la operación sea exitosa al llegar a una siguiente página de bienvenida.

var zombie = require("zombie");
var assert = require("assert");


// Carga la página desde el localhost
zombie.visit("http://localhost:3000/", function (err, browser) {


  // Completa email y password y confirma el formulario
  browser.
    fill("email", "zombie@underworld.dead").
    fill("password", "eat-the-living").
    pressButton("Sign Me Up!", function(err, browser) {


      // Al procesar el form, ve si fue a la página correcta
      assert.equal(browser.text("title"), "Welcome To Brains Depot");
    })
});

Como se ve, el API es muy sencilla y natural, y como siempre en Node, no hay llamadas bloqueantes; todo lo que pasa se maneja con callbacks, lo que hace también que correr una batería importante de pruebas sea más rápido en total, facilitando la ejecución más frecuente, lo que siempre eleva la calidad del proceso de desarrollo.

 

Javascript ya no es lo que era

Mario Kart

Siguiendo con las pruebas de cuánto se puede llegar a hacer con Javascript (más características de HTML5 como Canvas), aquí hay otra implementación de un juego clásico: Mario Karts. Por ahora sólo se trata de la carrera, sin obstáculos especiales ni armas, pero no está mal para 11 Kb, sobre todo porque lo impresionante es la velocidad a la que se mueve la pista.

Pero no me crean a mi. Veanlo ustedes mismos, con algún navegador moderno que tenga buen soporte para HTML5 y un motor rápido de Javascript. Firefox 3.x en adelante, Chrome o Safari funcionan. No probé con Internet Explorer 9 Beta, pero debería funcionar bien (espero reportes).

Y como verán en la página, pueden ver detalles sobre la implementación, y si piensan que es un ejemplo aislado, vean todos los juegos que hay en esta colección hechos a puro Javascript.

martes, 4 de enero de 2011

Mono en Android disponible para todos

MonoDroid

Después de un tiempo bajo un programa beta limitado, el equipo de Mono ha abierto finalmente la versión preliminar de MonoDroid para todo el mundo.

Con esta nueva versión preliminar, además, agregaron soporte para desarrollo en Mac OS utilizando MonoDevelop con el AddIn corespondiente.

Mono en Android instala la máquina virtual de Mono, con una versión reducida de las bibliotecas conteniendo sólo lo que tiene sentido en un dispositivo Android.

Además de permitir de esta manera programar en C# en lugar de Java (el único lenguaje completamente soportado por Google en Android), MonoDroid incluye una adaptación completa de las APIs de Dalvik (la máquina virtual de Android) con una interfaz mucho más familiar para desarrolladores C#, incluyendo propiedades, eventos, tipos genéricos, y realizando conversiones de manera automática cuando es necesario.

Más detalles en el post de anuncio de Miguel de Icaza (en inglés).

Aprovechando que se ha liberado y agregaron soporte completo para Mac, les dejo unas imagenes capturadas tras actualizar mi entorno y probar la aplicación que viene como plantilla (estilo Hello, World).

Así se ve la solución y la actividad principal inmediatamente después de crear un nuevo proyecto Android:

Android en MonoDevelop

Se puede hacer debugging en emuladores o dispositivos reales. El SDK de Android trae emuladores genéricos y se pueden generar otros para modelos específicos obteniendo el kit del fabricante para Android. Motorola, por ejemplo, los provee para mi Milestone y otros dispositivos con Android.

En la práctica es muchísimo más rápido probar contra el teléfono. La primera vez tarda un poco más porque instala el runtime, pero las siguientes va mucho más rápido. Los emuladores me dan la impresión de ser unas 5 o 6 veces más lentos (al menos que mi teléfono). La ventaja de los emuladores es que se pueden capturar más fácilmente las pantallas, como en el ejemplo debajo, que muestra uno genérico recién iniciado:

Emulador

Y finalmente, la emocionante aplicación de ejemplo, funcionando en el emulador. Cada vez que tocamos el botón incrementa el número de clicks. No está tan mal para ser algo que el entorno  genera solo, sin tener que modificar un solo caracter:

Aplicación de ejemplo

 

lunes, 3 de enero de 2011

Ronda de editores de texto para Mac

Editores de Texto

Un compañero de trabajo que desembarcó recientemente en territorio Mac me preguntaba el otro día sobre editores de texto, que es algo que todo programador necesita tener a mano. Como mencionan en el clásico libro de nuestra profesión, The Pragmatic Programmer, así como un buen leñador invierte gran parte de su tiempo afilando el hacha, que es lo que lo mantiene productivo, nosotros deberíamos siempre seleccionar con cuidado y luego dominar esta herramienta que usamos permanentemente. Incluso es difícil quedarse con un único editor de texto (sin contar además con una IDE, en muchos casos).

En particular soy más amigo de los buenos editores que de las IDEs, así que después de comentarle brevemente a mi amigo algunos de los editores que uso, decidí preparar este post con una lista (incompleta) de los más interesantes que he visto o usado en OS X.

Cuando llegué ya estaba ahí: TextEdit

Este es el editor que viene como parte del sistema operativo, y aunque muchos no lo saben, este pequeño editor tiene algunas características interesantes, como soporte no solo para ASCII plano sino también para Unicode UTF-8 o 16, Rich-Text Format (RTF), .doc ó -docx (si, formato Word XML).

Otro detalle interesante es que los fuentes de este editor están incluidos como muestra en la IDE de Mac OS: XCode.

El más popular: TextMate

TextMate es el editor más popular en este ambiente, basado en mi propia experiencia, incluso a pesar de ser un producto comercial.

Algunos de los motivos más importantes detrás de su éxito son su flexibilidad y extensibilidad, a través de los bundles: extensiones que permiten no sólo dar soporte a coloreo de sintaxis y operaciones específicas para cada lenguaje, sino también para automatizar operaciones alrededor del sistema operativo, los browsers, compiladores y demás piezas de infraestructura.

Un buen ejemplo de esa flexibilidad es el meta-bundle llamado GetBundles que permite actualizar los cientos de bundles disponibles y que la comunidad sigue generando activamente. Y la comunidad, casualmente, es otra característica muy importante. Basta con buscar en GitHub para ver la cantidad de extensiones, y ver que hay bundles como el de Ruby mantenidos por gente como David Heinemeier Hansson, el creador mismo de Ruby on Rails.

Fuerte en Proyectos: BBEdit

Este es otro editor sumamente popular, que parece haber sido sobrepasado por TextMate sobre todo por el soporte para Ruby/Rails. Sin embargo, BBEdit sigue siendo un favorito, también comercial, aunque casi al doble de precio de TextMate.

El fuerte de este editor, además de muchas características avanzadas similares al anterior, es en el manejo de proyectos, que permite utilizar múltiples carpetas, filtros por tipos de archivo, etc. En el ambiente C++ y Objective C sigue siendo muy utilizado.

Todoterreno: UltraEdit para Mac

Para quienes usan o usaron este poderoso editor comercial en Windows o Linux, ahora está disponible la versión para Mac, lo que puede darles la ventaja de la familiaridad y supuestamente portabilidad de macros y algunas extensiones.

Para quienes no lo utilizaron antes, la interfaz, aunque re-escrita en Cocoa, parece aun un poco extraña en Mac OS, notándose su procedencia de ora plataforma.

Sus características más famosas son macros, poderosa búsqueda y reemplazo incluso entre múltiples archivos, y la capacidad de trabara directamente sobre servidores via FTP.

Clásico de clásicos: Vim y Aquamacs

Como Mac OS es un Unix maquillado, Vi / Vim siempre fueron opciones importantes y gratuitas. Este clásico editor tiene una personalidad fuerte y no es para quienes están acostumbrados a menúes o interfaces gráficas. Es super-eficiente en el uso de combinaciones de teclas pero para mucha gente parece una vuelta atrás en el tiempo.

Hace poco publiqué un post con una cartilla para facilitar el uso. Mi recomendación es darle una oportunidad, sobre todo si uno es más usuario de un editor que de una IDE.

Por supuesto, respetando la diversidad religiosa, también hay una versión de Emacs para Mac OS (modo totalmente regular estilo texto) o una versión más adaptada, con fonts, menúes y uso de las clásicas secuencias de teclas de Mac, llamada Aquamacs.

Más opciones gratuitas interesantes: Kod y TextWrangler

Para cerrar, otro par de editores gratuitos muy buenos:

Sobre Kod escribí un post reciente, así que no voy a repetir mucho.

TextWrangler es como el hermano menor, freeware (no de código abierto) de BBEdit, y funciona muy bien. Soporta múltiples lenguajes con coloreo de sintaxis y acceso directo al shell del sistema operativo, extensibilidad y varias otras funciones interesantes.

 

Como cierre, repito que la lista está obviamente incompleta, y si les parece que hay otras opciones buenas o quieren destacar alguna característica buena o mala, o sus experiencias, los invito a dejar comentarios.

Finalmente, recomiendo a cualquier programador invertir un tiempo en probar algunos de los editores, y después de selecionar uno o dos, dedicarle un poco más a aprenderlo a fondo. Ahorrar tres o cuatro horas de investigación del poder de un editor puede significar perder ese mismo tiempo todos los meses haciendo cosas que podemos automatizar.