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.