Leisure Suit Larry en HTML5

La aparición de nuevas librerías para gráficos y animación en HTML5 / JavaScript han posibilitado una avalancha de regresos a juegos clásicos que se adaptan bien a ser ejecutados en el browser.

Y aunque ya se pueden encarar estilos más ambiciosos, los clásicos siguen volviendo. Esta vez encontré una versión sumamente fiel de un clásico de los 80: Leisure Suit Larry. Para quienes lo jugaron en aquella época o m's tarde, ya que su popularidad lo mantuvo vivo bastante tiempo, he aquí una oportunidad de revivir esos momentos sin tener que recurrir a la virtualización.

Algo interesante de este juego y otros clásicos disponibles en el mismo sitio, es que están autorizados por las compañías que mantienen los derechos de los juegos originales, Activision y CodeMasters.

Pero además están construidos sobre un par de componentes  para juegos licenciado bajo GPL o MIT, y disponibles en Google Code:

• El intérprete Sarien.Net, que es una implementación sobre el browser del motor original usado por Sierra On-Line para los juegos originales Space Quest, Police Quest y el de Larry.
  
  
• El motor multiplayer Q42 es una plataforma multi-usuario sumamente liviana para juegos basados en el browser, siempre por puerto 80. El API cliente son 5K de JavaScript, y el servidor es una clase en C# que puede embeberse o referenciarse como una DLL externa (imagino que probablemente pueda correr en Mono, pero habría que probarlo).
  
  El motor implementa básicamente un mecanismo de chat con salas separadas, escalamiento automático, liberación de salas vacías, propiedades por usuario como nombre y posición (x,y), mensajería y soporte para múltiples usuarios por sesión, lo que permite mantener usuarios distintos en tabas separados del mismo browser, por ejemplo.

Espero que alguno se divierta con esto, jugando o programando.

Meditación programática: Koans

Los Köan (pronunciación japonesa del chino 公案) o Koan, son ejercicios mentales de la meditación Zen, consistentes en diálogos o preguntas que plantean un problema que muchas veces no tiene respuesta directa. El objetivo de un Koan es el aprendizaje durante el proceso de elaboración de la respuesta, más que la respuesta en sí.

Un ejemplo clásico es la pregunta: "Cuando dos manos aplauden hay un sonido. ¿Cuál es el sonido de una sola mano?".

Tomando esta idea como base, de manera similar a la idea de los Code Katas que comentaba en un post reciente, diferentes personas empezaron a generar Code Koans para diferentes lenguajes. Como siempre, la adaptación es libre y no sigue exactamente los mismos principios, sino que e inspira en la idea motora.

Los Koans dentro del campo de la programación parten del objetivo de comenzar con conceptos sumamente básicos y realizar ejercicios generalmente abiertos, pero que frecuentemente llevan a la necesidad de experimentar o investigar un poco más allá del alcance mismo del planteo.

Hay colecciones de Koans para varios lenguajes, entre ellos Ruby Koans (Jim Weirich y Joe O'Brien), JavaScript Koans (Liam McLennan), .NET Koans (Cory Foy) y los Clojure Koans (Aaron Bedra).

La mayoría de estos proyectos están inspirados en el primero, los Ruby Koans, de los que incluyo algunos ejemplos para que se entienda el concepto general.

Los Koan suelen estar agrupados por temas, por ejemplo en los de Ruby, hay series para arrays, blocks, clases, excepciones, módulos, strings, y muchas más.

Los Koans se basan siempre en la práctica de Test-Driven Development (curso gratuito en español disponible), donde las "preguntas" están formuladas como tests, que el aprendiz debe implementar y pasar. La diferencia con TDD tradicional es que el test principal ya está escrito (lo que no significa que no podamos agregar más).

Lo primero a ejecutar en los Ruby Koans es (desde la línea de comandos):

$ ruby path_to_enlightenment.rb

y el resultado es algo como:

AboutAsserts#test_assert_truth has damaged your karma.

The Master says:
  You have not yet reached enlightenment.
  Do not lose hope.

The answers you seek...
  Failed assertion, no message given.

Please meditate on the following code:
  /Users/ . . . /koans/about_asserts.rb:10:in `test_assert_truth'

mountains are merely mountains
your path thus far [X_________________________________________________] 0/274

El mensaje juega con el estereotipo del Maestro Zen y el estilo de los consejos, pero más allá de eso, nos da un indicio: nos dice que meditemos en el método test_assert_truth dentro del archivo about_asserts.rb. Si abrimos este archivo y lo miramos, encontramos este test donde el motivo de la falla es más que obvio:

  # We shall contemplate truth by testing reality, via asserts.
  def test_assert_truth
    assert false                # This should be true
  end

Al cambiar a assert true y ejecutar de nuevo, obtenemos un mensaje similar sobre el siguiente test que falla, y otra frase Zen diferente para inspirarnos. Por supuesto, a medida que avanzamos la respuesta es menos evidente que cambiar un false a true. El primer ejercicio solamente sirve para que entendamos el procedimiento.

En varios casos, la manera de resolver el test no es evidente y tenemos que buscar más información en libros o en la web, pero esto es lo que buscan los Koans: forzarnos a aprender algo, pero siguiendo baby steps.

Microsoft 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.

 

Zapatero a tus zapatos; con Ruby

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":

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:

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:

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.

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

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.