jueves, 31 de marzo de 2011

Yoseki Coding Dojo en Kleer

Siguiendo con la buena costumbre de los Coding Dojo, mis amigos de Kleer vienen organizando algunas de estas sesiones abiertas para escribir código entre muchos, como un ejercicio de trabajo en grupo, programación y entretenimiento. Ellos ya tienen un formato bastante definido para estas sesiones, llamadas Yoseki Coding Dojo en las que se van variando el lenguaje y el entorno.

Kleer Dojo

El martes de esta semana me sumé a esta actividad, me encontré con otro amigo asistiendo, Carlos Peix, y me di el gusto de compartir con él la primera ronda de pair programming.

Esta vez trabajamos con Java/Eclipse. Parece que el próximo Yoseki será en Ruby, y si me dejan haremos uno en Javascript.

El problema que planteó el facilitador de turno, Pablito "Pablitux" Tortorella: escribir un contador de puntos de tenis. A continuación dejo las premisas generales para quien quiera practicar este Code Kata. Recuerden que la idea es realizar el ejercicio utilizando TDD, y puede hacerse como una Kata individual, o en un Dojo con varias personas.

La idea es hacer un contador de puntos de tenis. No soy experto en tenis y no me quedaron a mano los detalles que Pablo iba mostrando como historias de usuarios, pero creo que todos sabemos un poco cómo se cuenta: "15 - 0", "30 - 0", "40 - 0"; después los sets; detalles de convención como "30 iguales", etc.

Les dejo debajo los primeros tests (a propósito no dejo todos por si alguno quiere intentar por su lado). Quienes quieran pueden ver los fuentes completos de los tests y de la implementación.

Primeros tests:

package la.kleer.yoseki.tenis.tests;

import junit.framework.Assert;
import la.kleer.yoseki.tenis.Tablero;

import org.junit.Test;

public class TenisFixture {
   
   @Test
   public void tableroTituloConDosJugadores()
   {
      Tablero t = new Tablero("Martin", "Carlos");
      Assert.assertEquals("Martin vs Carlos", t.getTitulo());
   }

   @Test
   public void tableroTituloConDosJugadoresAlReves()
   {
      Tablero t = new Tablero("Carlos", "Martin");
      Assert.assertEquals("Carlos vs Martin", t.getTitulo());
   }
   
   @Test
   public void tableroPuntajeInicial()
   {
      Tablero t = new Tablero("Carlos", "Martin");
      Assert.assertEquals("0 - 0", t.getPuntaje());
   }
   
   @Test
   public void puntosJ1()
   {
      Tablero t = new Tablero("Carlos", "Martin");
      t.puntoJugador1();
      Assert.assertEquals("15 - 0", t.getPuntaje());
   }
   
   @Test
   public void puntosJ2()
   {
      Tablero t = new Tablero("Carlos", "Martin");
      t.puntoJugador2();
      Assert.assertEquals("0 - 15", t.getPuntaje());
   }

   @Test
   public void puntosJ1_J1()
   {
      Tablero t = new Tablero("Carlos", "Martin");
      t.puntoJugador1();
      t.puntoJugador1();
      Assert.assertEquals("30 - 0", t.getPuntaje());
   }

   @Test
   public void puntosJ1_J2()
   {
      Tablero t = new Tablero("Carlos", "Martin");
      t.puntoJugador1();
      t.puntoJugador2();
      Assert.assertEquals("15 iguales", t.getPuntaje());
   }
   // Aquí van más tests
}

Finalmente, les dejo una foto del grupo en acción:

Yoseki Coding Dojo

 

miércoles, 30 de marzo de 2011

Akshell: Una IDE completa en línea

Akshell

Hace rato vengo esperando ver algo como esto. Hubo intentos anteriores auspiciosos, pero esta vez creo que se aproxima mas a mis expectativas porque además plantea un flujo de trabajo bastante completo.

Publico la reseña antes de hacer muchas pruebas porque me entusiasmó el proyecto: Akshell

Se trata de un entorno de desarrollo en línea completo, para Javascript, incluyendo integración directa con Git y GitHub, y despliegue automatizado (incluyendo un entorno de pruebas provisto, pero que puede enviar a cualquier dominio).

Soporta (por ahora) PostgreSQL utilizando un API de Javascript, e incluye un framework propio de pruebas unitarias basado en la biblioteca unit test de Python.

Veamos rápidamente un pantallazo del entorno, con una mínima aplicación de prueba:

Akshell IDE

Como se ve, hay manejo de proyectos, y en el navegador de la izquierda se ven los diferentes entornos (release y debug por omisión).

El editor tiene coloreo de sintáxis, y también por omisión hay un motor simple de templates para manejar el HTML de la aplicación y hacerlo interactuar con los scripts, como en este ejemplo:

{% extends 'base.html' %}

{% block title %}{{ entry.title }}{% endblock %}

{% block content %}
  {{ entry.title }}
  {{ entry.author }}
  {{ entry.message }}
{% endblock %}

Por ahora esto apunta a un modelo de aplicación bastante específico, pero bastante bien documentado y no lejano a cualquier framework web moderno.

Espero probar un poco más el entorno y poder compartir más datos, y ojalá otros compartan sus experiencias si hacen la prueba.

martes, 29 de marzo de 2011

Cuba: un micro-framework para desarrollo web basado en Rum

Suba

(Después de un lapsus entre feriados largos y proyectos, vuelvo a la carga)

En el último Ruby Meetup en Buenos Aires, del que hablé un poco más en el último post hace una semana, otra de las presentaciones correspondió a Michel Martens (soveran, en GitHub), quien presentó Cuba, su microframework inicialmente basado en el proyecto anterior Rum, otro pequeño mapper sobre Rack, pero que quedó discontinuado.

Rack es una abstracción que muchos de los frameworks web de Ruby utilizan para evitar reimplementar toda la interacción básica con un servidor web. Es básicamente una interfaz estandarizada sobre el servidor, independiente de cada implementación particular (soporta Mongrel, WEBrick, FCGI, Thin, y otros).

Rack surgió básicamente como una alternativa a Ruby on Rails, pero hoy hay Rails también puede utilizar Rack por debajo.

Muchos de los frameworks más chicos, como Sinatra, Camping o Merb construyen una capa de aplicación muy fina por encima de Rack, con lo que obtienen un modelo más limpio (obviamente con mucha menos magia que Rails), pero más eficiente cuando uno está dispuesto a trabajar un poco en algunas características en pos de más velocidad, menos consumo de recursos y muchas veces, más claridad en la solución final.

Cuba es otro de estos microframeworks, y tiene algunas características muy interesantes, que me sorprendieron en la presentación de Michel:

  • Es realmente minimalista, muy cerca del mismo Rack, lo que otorga mucho control sobre el flujo de trabajo del servidor web.
  • A pesar de tener algunas similaridades con Sinatra, es todavía más rápido, y más explícito.
  • Integra plantillas para vistas usando Tilt y testing utilizando Cutest y Capybara, aunque es trivial integrar cualquier otra cosa.

Veamos un ejemplo mínimo para entender que tan simple y de bajo nivel es Cuba:

require "cuba"

Cuba.use Rack::Session::Cookie

Cuba.define do
  on get do
    on "hello" do
      res.write "Hello world!"
    end

    on true do
      res.redirect "/hello"
    end
  end
end

Por supuesto hay oportunidades para abstraer todo un poco más pero se puede notar como se puede manipular de manera explícita la respuesta del servidor (res). Esto en Sinatra es más implícito, lo que está bien para muchos casos pero a veces es bueno poder acceder y manipular la respuesta de manera directa.

Aclaro que no tuve oportunidad de probar mucho Cuba, pero me parecieron interesantes algunos de los principios de diseño y los resultados obtenidos, y más aún saber que es un proyecto que está vivo y en manos de alguien que tenemos cerca.

miércoles, 23 de marzo de 2011

Navegadores actualizados: lo bueno, lo malo y lo feo

En estos últimos días hubo muchísima actividad alrededor de los navegadores web principales.

Por todos lados resonó el lanzamiento de FireFox 4, y con menos ruido desde la comunidad pero mucha promoción se lanzó también Internet Explorer 9. Por su parte, sin tanto ruido, Google Chrome siguió actualizándose silenciosamente y en mi caso pasó a la versión 11 Beta (quienes no están suscriptos al canal beta deberían estar alrededor de la versión 10.0.648.15).

A continuación algunos detalles, apreciaciones y recursos que me parecen interesantes para desarrolladores:

IE 9

Internet Explorer 9

Esta versión es una imprescindible actualización de Microsoft, mientras hace esfuerzos denodados por eliminar los últimos restos de IE 6, que ya es un problema grave hasta para ellos mismos.

Casualmente, días antes del lanzamiento de IE 9 lanzaron también la campaña http://ie6countdown.com/ que me parece llena de problemas. Este sitio propone incorporar un banner que se activa si el navegador con que se accede al sitio es IE 6, pero en caso que el usuario en cuestión le preste atención y haga clic en el banner, es derivado al sitio de Internet Explorer, donde lo más probable es que termine descargando Explorer 8, no el 9.

He aquí uno de los principales problemas que veo en IE 9: no tiene soporte en Windows XP, un sistema operativo que sigue teniendo un nivel de presencia enorme, y que es el que deben estar utilizando la mayor cantidad de los usuarios que usan aún IE6. El resultado es que muchos de esos usuarios quedarán usando un navegador que todavía no cumple con los estándares modernos.

Fuera de este detalle, IE 9 se puso al día y soporta una buena cantidad de los últimos estándares conocidos como HTML 5. No implementa todos porque Microsoft tomó la decisión de no atacar estándares que no estén a cierto nivel de decisión, con lo que en la práctica hay cosas que otros navegadores soportan y IE9 no, pero el argumento es al menos atendible y la brecha es mucho menor.

IE9 es muy rápido, usa muy bien la aceleración gráfica, y tiene algunas características interesantes en cuanto a su integración con Windows. Claro, sólo corre en Windows, lo que es otra gran diferencia con respecto a los demás.

Para quienes estén interesados, Microsoft Argentina realizará un evento gratuito sobre las novedades, el próximo lunes 28, en sus oficinas de Bouchard 710, 4to piso, en Buenos Aires. Aunque es gratuito, requiere registración. Para más detalles y registro ver el post de Miguel Sáez sobre el evento.

Firefox 4

Firefox 4

Mozilla finalmente liberó la nueva versión de su producto más famoso. Desde el punto de vista de los cambios visibles, en varias áreas comparte con IE9 el acercarse más a algunos principios establecidos por Chrome, como minimizar el espacio que el navegador mismo toma de la pantalla, dejando todo lo posible para el contenido.

También avanza en mayor soporte para los estándares, y aunque la versión acaba de salir, un dato importante para los desarrolladores es que FireBug ya está actualizado para esta versión.

Otro aspecto interesante es que esta va a ser la última entrega de Firefox que se deba descargar e instalar. A partir de ahora, las actualizaciones también seguirán el mecanismo de "goteo" de Chrome, y el navegador se mantendrá actualizado en forma paulatina, sin mayor intervención del usuario, aunque algunas actualizaciones queden a la espera de que el navegador -o el sistema completo- se reinicie.

Chrome

Chrome

Una de las novedades más importantes de Chrome es que cambió el logo/icono, como pueden ver.

Hablando un poco más en serio, los cambios son como siempre incrementales, y en el caso de la versión beta, experimentales. Por ejemplo, ya están probando algunas APIs de voz y usando aceleración gráfica para el soporte 3D en las hojas de estilo.

Más adelante se ve venir que están por quitar Gears de Chrome, ya que esta extensión existía para dar soporte a características que ya se han implementado en HTML5. Sin embargo, muchas opciones de soporte fuera de línea de aplicaciones como GMail, Calendar y Docs lo utilizan, por lo que no sería raro ver que pronto estos productos migren hacia los nuevos estándares.

 

lunes, 21 de marzo de 2011

Video: Ruby Meetup en Buenos Aires

Ruby Argentina

Como comenté en un post hace poco, la semana pasada se realizó la 7ma Ruby Meetup en Buenos Aires, organizada por la comunidad Ruby Argentina.

Como las anteriores, se hizo gracias a la colaboración de Urban Station, en Palermo, que presta el espacio, y organizada principalmente por Ernesto Tagwerker y Nacho Carrera.

Pude asistir y me tocó presentar una de las charlas relámpago, pero sobre todo pude conocer a mucha gente interesante del ambiente, que espero ver más seguido.

También presentó Michel Martens su microframework para desarrollo web llamado Cuba, que tiene similaridades con Sinatra pero es más rápido y liviano todavía. Sumamente recomendable, y espero publicar pronto el video en un post aparte.

También tuve la oportunidad de grabar un poco de la reunión, y comparto el segmento de introducción donde pueden ver a Ernesto y Nacho, y luego la presentación de Ernesto sobre cómo colaborar en proyectos de código abierto utilizando GitHub. Es una recorrida muy breve pero interesante, aunque pido disculpas de antemano porque la cámara a veces debería haber tomado más directamente la pantalla. No es fundamental, de todas maneras, ver el código del ejemplo, sino entender la explicación.

Dejo también dentro del canal de Code & Beyond videos de reuniones anteriores subidos por Nacho, con charlas más extensas.

jueves, 17 de marzo de 2011

El juego de la vida en HTML5 usando Canvas

El juego de la vida de Conway (también conocido simplemente como "Life") es un ejemplo clásicos de Autómatas Celulares creado por John Horton Conway en los 70.

Consiste en una grilla de puntos (el universo) donde cada punto puede contener un individuo o célula (un punto de la grilla que está encendido o vivo (los puntos tienen estado binario: vivos o muertos).

El juego funciona sólo (se lo conoce como un juego de cero jugadores), y lo único que se puede hacer es preparar el estado inicial y luego echarlo a correr. La corrida involucra generaciones, o pasadas por la grilla completa para analizar el estado y calcular el de la siguiente pasada. El cálculo se hace analizando para cada punto su estado y el de los ocho que lo rodean (sus vecinos):

Celula y Vecinos

Para determinar si la célula analizada vive o muere, se aplican las siguientes reglas:

  • Una célula viva con menos de dos vecinos vivos se muere (de soledad)
  • Una con dos o tres vecinos vivos sobrevive
  • Una con más de tres vecinos vivos se muere (por sobrepoblación)
  • Una célula muerta con exactamente tres vecinos vivos, nace (por reproducción)

La grilla debe considerarse como un toroide, o sea que los puntos de la última fila continúan en la superior, y los de la última columna derecha continúan en la primera de la derecha y viceversa.

Parece sencillo, pero ha sido estudiado durante todos estos años no solamente como un interesante Code Kata, sino como un interesante ejercicio de simulación de ecosistemas.

Como no hay mejor manera de entenderlo que verlo en acción, les recomiendo ver esta versión implementada en HTML 5, utilizando el tag Canvas.

Cosas interesantes que ocurren con este juego es que espontáneamente aparecen configuraciones estables (que permanecen constantes durante muchas generaciones, variando entre un número determinado de estados. Es un interesante ejemplo de comportamiento emergente, y aunque parezca un oximorón, un ejemplo sencillo de sistemas complejos.

Juego de la Vida

Por supuesto, una de las cosas muy interesantes de ver es código fuente. Son sólo 234 líneas de JavaScript y aunque parece un poco largo para un post, creo que vale la pena pegarlo completo, aunque recomiendo que si alguien lo quiere tocar baje siempre la última versión disponible en GitHub.

 

/*
 * Copyright 2011 Julian Pulgarin 
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0

 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

var Point = function(x, y) {
    this.x = x;
    this.y = y;
};

var graphics = function() {
    var canvas;
    var ctx;
    var canvasId;

    var cellSize = 10; // pixels
    var onColour = 'rgb(0, 200, 0)';
    var offColour = 'rgb(200, 0, 0)';
    var gridColour = 'rgb(50, 50, 50)';

    var initCanvas = function(canvasId) {
        this.canvas = $(canvasId).get(0);
        this.ctx = this.canvas.getContext('2d'); 
        this.canvasId = canvasId;
    }

    var drawCell = function(x, y, alive) {
        var g = graphics;
        g.ctx.fillStyle = (alive)? onColour : offColour;
        g.ctx.fillRect(x * cellSize + 1, y * cellSize + 1, cellSize - 1, cellSize - 1);
    }

    var handleMouse = function(e) {
        var l = life;
        var g = graphics;
        var that = this;
        var cell = getCellPointUnderMouse(e);
        var state;
        processCell(cell);
        $(g.canvasId).mousemove(function(e) {
            cell = getCellPointUnderMouse(e);
            processCell(cell);
        });
        function getCellPointUnderMouse(e) {
            return new Point((e.pageX - that.offsetLeft) / g.cellSize | 0, ((e.pageY - that.offsetTop) / g.cellSize) | 0);
        }
        function processCell(cell) {
            var x = cell.x;
            var y = cell.y;
            if (x > l.xCells - 1 || y > l.yCells - 1) {
                return;
            }
            if (typeof state == 'undefined')
            {
                state = !l.prev[x][y];
            } 
            l.prev[x][y] = state;
            drawCell(x, y, state);
            // TODO: Consider setting next as well
        }
    }

    function paint() {
        var g = graphics;
        var l = life;

        for (var x = 0; x < l.xCells; x++) {
            for (var y = 0; y < l.yCells; y++) {
                g.drawCell(x, y, l.prev[x][y]);
            }
        }
    }

    return {
        canvas: canvas,
        ctx: ctx,
        canvasId: canvasId,
        cellSize: cellSize,
        onColour: onColour,
        offColour: offColour,
        gridColour: gridColour,
        initCanvas: initCanvas,
        drawCell: drawCell,
        handleMouse: handleMouse,
        paint: paint,
    }
}(); 

var life = function() { 

    var yCells; 
    var xCells;
    var prev = []; // previous generation
    var next = []; // next generation

    var _timeout;
    var _alive = false;

    var initUniverse = function(canvasId) {
        var l = life;
        var g = graphics;
        g.initCanvas(canvasId);
        l.xCells = ((g.canvas.width - 1) / g.cellSize) | 0;
        l.yCells = ((g.canvas.height - 1) / g.cellSize) | 0; 
        g.ctx.fillStyle = g.offColour;
        g.ctx.fillRect(0, 0, l.xCells * g.cellSize, l.yCells * g.cellSize);
        g.ctx.fillStyle = g.gridColour;

        for (var x = 0; x < l.xCells; x++) {
            l.prev[x] = [];
            l.next[x] = [];
            g.ctx.fillRect(x * g.cellSize, 0, 1, l.yCells * g.cellSize);
            for(var y = 0; y < l.yCells; y++)
            {
                l.prev[x][y] = false;
            }
        }
        g.ctx.fillRect(l.xCells * g.cellSize, 0, 1, l.yCells * g.cellSize);
        for(var y = 0; y < l.yCells; y++)
        {
            g.ctx.fillRect(0, y * g.cellSize, l.xCells * g.cellSize, 1);
        }
        g.ctx.fillRect(0, l.yCells * g.cellSize, l.xCells * g.cellSize, 1);
        $(canvasId).mousedown(g.handleMouse);
        $('body').mouseup(function(e)
        {
            $(g.canvasId).unbind('mousemove');
        });
    }

    var nextGen = function() {
        var l = life;
        var g = graphics;

        for (var x = 0; x < l.xCells; x++) {
            for (var y = 0; y < l.yCells; y++) {
                l.next[x][y] = l.prev[x][y];
            }
        }

        for (var x = 0; x < l.xCells; x++) {
            for (var y = 0; y < l.yCells; y++) {
                count = _neighbourCount(x, y);

                // Game of Life rules
                if (prev[x][y]) {
                    if (count < 2 || count > 3) {
                        next[x][y] = false;
                    }
                } else if (count == 3) {
                    next[x][y] = true;
                } 
            }
        }

        for (var x = 0; x < l.xCells; x++) {
            for (var y = 0; y < l.yCells; y++) {
                l.prev[x][y] = l.next[x][y];
            }
        }

        g.paint();
    }

    var toggleLife = function() {
        var l = life;

        if (!l._alive) {
            l._alive = true;
            l._timeout = setInterval("life.nextGen()", 100);
        } else {
            l._alive = false;
            clearInterval(l._timeout);
        }
    }

    var clear = function() {
        var l = life;
        var g = graphics;

        for (var x = 0; x < l.xCells; x++) {
            for (var y = 0; y < l.yCells; y++) {
                l.prev[x][y] = false;
            }
        }
        g.paint();
    }

    var _neighbourCount = function(x, y) {
        var l = life;
        var count = 0;
        var neighbours = [
            l.prev[x][(y - 1 + l.yCells) % l.yCells],
            l.prev[(x + 1 + l.xCells) % l.xCells][(y - 1 + l.yCells) % l.yCells],
            l.prev[(x + 1 + l.xCells) % l.xCells][y],
            l.prev[(x + 1 + l.xCells) % l.xCells][(y + 1 + l.yCells) % l.yCells],
            l.prev[x][(y + 1 + l.yCells) % l.yCells],
            l.prev[(x - 1 + l.xCells) % l.xCells][(y + 1 + l.yCells) % l.yCells],
            l.prev[(x - 1 + l.xCells) % l.xCells][y],
            l.prev[(x - 1 + l.xCells) % l.xCells][(y - 1 + l.yCells) % l.yCells],
        ];

        for (var i = 0; i < neighbours.length; i++) {
            if (neighbours[i]) {
                count++;
            }
        }
             
        return count;
    }

    return {
        yCells: yCells,
        xCells: xCells,
        prev: prev,
        next: next,
        initUniverse: initUniverse,
        nextGen: nextGen,
        toggleLife: toggleLife,
        clear: clear,
    }
}();

miércoles, 16 de marzo de 2011

En el jardín del buen y del mal JavaScript

Better JS Docs

Dos especialmente dedicados miembros de la comunidad de desarrolladores StackOverflow, Ivo Wetzel (23 años, trabajando en Zynga Alemania) y Yi Jiang (17 años, estudiante de Singapur) , han construido el sitio JavaScript Garden, dedicado a corregir errores de interpretación y mejorar el entendimiento sobre este fantástico lenguaje.

Además de ser un ejemplo de sobriedad y buen diseño (noten la fluidez de la navegación desde el menú a la derecha), me parece un gran trabajo de difusión, cubriendo por áreas las particularidades de JavaScript que suelen confundir a algunos programadores proveniendo de entornos bastante diferentes.

Algunos ejemplos que tomo del sitio:

Objetos y propiedades

En JS todo es u objeto, excepto null y endefined.

false.toString() // 'false'
[1, 2, 3].toString(); // '1,2,3'

function Foo(){}
Foo.bar = 1;
Foo.bar; // 1 

Es común pensar que los números literales no pueden tratarse como objetos porque no se puede acceder a sus miembros de la manera tradicional, pero esto es un defecto histórico del parser, que puede subsanarse fácilmente utilizando doble punto o espacios, como se muestra aquí:

2.toString(); // arroja SyntaxError

2..toString(); // el segundo punto hace que se interprete bien
2 .toString(); // o se puede dejar un espacio antes
(2).toString(); // o el uso de paréntesis también

En JS los objetos están implementados como hashmaps, o listas de elementos clave-valor, con lo que es posible crear objetos utilizando esta notación:

var foo = {}; //  objeto vacío (hereda de object.prototype)

// un nuevo objeto con la propiedad 'test' y valor 12
var bar = {test: 12}; 

Y las propiedades también pueden accederse como tales o como índices. Incluso al usar la notación con corchetes se pueden soportar propiedades que no serían posibles utilizando puntos, como en:

var foo = {name: 'Mafalda'}
foo.name; // Mafalda
foo['name']; // Mafalda

var get = 'name';
foo[get]; // Mafalda

foo.1234; // SyntaxError
foo['1234']; // funciona

Prototipos

Esta es una de las facetas más "raras" para muchos programadores provenientes de una cultura de orientación a objetos "canónica. De hecho escuché varias veces el argumento de que "JavaScript no es orientado a objetos porque no tiene clases ni herencia". Esto es totalmente falaz: JS es orientado a objetos, sólo que tiene herencia por prototipos, y no por clases. En este sitio tienen estos buenos ejemplos de cómo mantener una jerarquía tradicional utilizando cadenas de prototipos.

Hay mucha más información y no es mi objetivo repetir todo el sitio, por lo que les recomiendo dedicarle una hora a leerlo y hacer algunas pruebas. No lleva mucho más que eso y para muchos ahorrará muchos dolores de cabeza, o les permitirá valorar JavaScript como el lenguaje merece.

martes, 15 de marzo de 2011

Videos de PyCon 2011 (Atlanta, USA) y PyCamp 2011 (La Falda, Córdoba) la semana próxima

Pycon

La parte principal de la conferencia internacional de Python, PyCon 2011, ya terminó, y afortunadamente podemos disfrutar de enorme cantidad de videos de las sesiones (en inglés, claro).

Pueden recorrer los videos publicados (tengan en cuenta que después de varias páginas empiezan a aparecer videos de PyCon 2010 y 2009), o ver algunos de los que seleccioné (arbitrariamente, por supuesto) en esta lista:

PyAr

Para quienes no pudieron viajara a Atlanta (imagino que la mayoría de nosotros), hay una oportunidad de pasar unos días en la hermosa localidad de La Falda, en Córdoba, Argentina, la semana que viene, y asistir al PyCamp 2011.

Como es de costumbre se puede ver la lista de gente que va a ir o está interesada (sin confirmar todavía), y la lista de temas propuestos (entiendo que se discuten y seleccionan en el momento).

Para el final, les dejo el video de esta entrevista grabada en la PyCon 2011 con Guido Van Rossum, autor de Python y "benevolente dictador de por vida" del lenguaje:

 

lunes, 14 de marzo de 2011

Probar Haskell en tu navegador

Real World HaskellSiguiendo el camino que inicio _why con TryRuby.org, Chris Done creo TryHaskell.org, una página donde encontramos una consola interactiva para probar Haskell, el lenguaje puramente funcional por excelencia.

Esta consola es del tipo REPL (read, evaluate, print loop) y permite ingresar comandos y expresiones. Como en Haskell la declaración de funciones es una expresión (utilizando let) se pueden crear y ejecutar funciones dentro del entorno.

Por supuesto, como en el caso de TryRuby, se puede seguir un tutorial que va guiando al asistente secuencialmente a través de las expresiones más sencillas, manipulación de strings, manejo de listas, declaración de símbolos, etc.

La consola interpreta y muestra los resultados parciales e informa si hay situaciones de error, como puede verse debajo.

Consola de Haskell

 

Adicionalmente a los ejemplos que la misma página va proponiendo, hay también un link al libro "Real World Haskell", de Bryan O'Sullivan, Don Stewart, y John Goerzen, editado por O'Reilly Media y disponible gratuitamente en línea (en inglés), donde se pueden encontrar muchísimos más ejemplos y por supuesto un nivel de profundidad mucho mayor en la presentación del lenguaje.

Para aprovechar a fondo la combinación entre el libro y TryHaskell basta con arrancar por el capítulo 1, donde se describen muchos ejemplos iniciales utilizando ghci, que es la consola interactiva del entorno Haskell, lo que es el equivalente directo de la consola que encontramos en la página.

Para todos aquellos interesados en la programación funcional pero que no tuvieron la oportunidad (o el coraje) de acercarse a Haskell, puede ser una buena manera de entender un poco más de que se trata sin la necesidad de tener que hacer una gran inversión inicial de tiempo.

 

viernes, 11 de marzo de 2011

Ruby Meetup en Buenos Aires

Ruby Argentina

La comunidad Ruby Argentina va a tener su próximo Ruby Meetup el próximo jueves 17 de marzo a las 19:00 en Buenos Aires.

El lugar de la reunión es Urban Station, el Salvador 4588, en el barrio de Palermo (mapa).

Los interesados pueden registrarse completando el formulario.

En esta reunión se decidió que se van a hacer varias lightning talks (charlas breves de 5 a 15 minutos), en base a los temas propuestos por los asistentes.

Los interesados en más detalles sobre el grupo pueden recurrir a los siguientes recursos:

También hay un sitio a nivel global, Ruby Meetup, en el que se pueden anotar los interesados en las reuniones, para estar al tanto de las que se realizan cerca.

Busqué videos introductorios de Ruby en español y no encontré mucho, a excepción de este de un evento en Tandil, Argentina, que es interesante aunque el ángulo desde el que está grabada la pantalla no es el ideal.

Me da la impresión de que es una área en la que podemos trabajar como comunidad. Ya me pondré en campaña.

Dejo el video tandilense por ahora, que no está (que yo sepa) relacionado con el grupo que organiza el meetup.

Espero ver a muchos lectores del blog en la reunión.

jueves, 10 de marzo de 2011

Python Tools for Visual Studio

Python Tools for Visual Studio

El equipo de Technical Computing de Microsoft acaba de liberar estas extensiones gratuitas y abiertas para dar soporte a Python dentro de su IDE de cabecera (por ahora en Beta 1).

Este equipo se dedica básicamente a dar soporte a escenarios de computación científica en ambientes distribuidos, clusters de computadoras, etc. Dentro de este ambiente, en el que Python también tiene un uso bastante intensivo como lenguaje de programación para MPI (Interfaz de pasaje de mensajes) que se utiliza para procesamiento en paralelo y distribuido, y mediante el uso de librerías como NumPy y SciPy.

Este plug-in para Visual Studio es producto de estas iniciativas construidas sobre el esfuerzo que hizo previamente el equipo de IronPython (la implementación de Python sobre el framework .NET), pero en este caso el soporte cubre tanto IronPython como el CPython standard, y tiene una serie de características muy interesantes, algunas ya disponibles y otras prometidas.

  • Intellisense, editor completo con coloreo, navegación de objetos y ventana de comandos integrada
  • Depuración local y remota (incluso en clusters)
  • Perfilamiento con múltiples vistas
  • Computación en paralelo interactiva desde la ventana de comandos
  • Soporte a clusters HPC y MPI, incluyendo depuración
  • NumPy y SciPy para .NET
  • Gratuita y de código abierto (licencia Apache 2.0)

Y prometidos para dentro de poco (esperemos que en la próxima Beta):

  • Soporte para Windows Azure
  • Soporte para Dryad (la implementación .NET de Linq para Map/Reduce)

Aunque en general en Python estamos acostumbrados a no usar Intellisense, hay que reconocer que el analizador que utilizan es bastante astuto, y es capaz de inferir los tipos de datos en contextos complejos, como se ve en el ejemplo:

Inferencia de Tipos

Otras características interesantes es la capacidad de saltar directamente entre fuentes, clases y métodos seleccionando de una lista que los agrupa correctamente, o saltar directamente a la definición de cualquier elemento desde algún uso en otra parte del código.

 

miércoles, 9 de marzo de 2011

Code & Beyond: más de 10.000 páginas vistas

El primer post de hoy (tras un fin de semana largo en Argentina) está dedicado a festejar una barrera: pasamos las 10.000 páginas vistas (pageviews).

Como siempre, es un número más, pero en honor al sistema decimal, vamos a revisar un poco las estadísticas del blog para entender qué pasó desde aquel primer post del 25 de octubre del año pasado (menos de 5 meses atrás):

Los post más leídos hasta ahora fueron:

¿Cómo llega la gente al blog?

A esta altura no debería sorprender mucho, pero la mayoría de las referencias iniciales son via Twitter y Google. Twitter.com aparece primero en la lista, aunque si sumamos los diferentes dominios, Google siempre gana. Primeros cinco puestos:

Referring Sites

¿De dónde vienen los lectores?

La mayoría son de mi país, Argentina, aunque imagino que el segundo puesto para USA probablemente mezcla gente hispano-parlante de allí con gente de otros sitios que por diversos motivos usan direcciones IP de USA, algo que es común.

Distribución por países

Me encantaría entender porque me leen desde Holanda y Corea del Sur. Si alguien tiene alguna teoría (no demasiado conspirativa) me encantaría leerla.

¿Qué navegador y sistema operativo usan los lectores?

Siendo seguramente una mayoría de la audiencia desarrolladores, como era esperable, más de la mitad usan navegadores con mejor soporte para desarrollo y más al día en cuanto a estándares, como Firefox y Chrome.

Por Navegador

Y en cuanto a los sistemas operativos, Windows sigue estando a la cabeza, pero es interesante ver más de un 10% de lectores usando Mac, como yo mismo, y casi la misma cantidad de otros Unix y Linux (todavía tengo un servidor con BSD). Espero poder seguir generando contenido que sea útil para todas esas comunidades. Me pareció interesante que haya gente que al parecer lee el blog desde el IPhone. Espero que la edición móvil sea cómoda de usar para ellos, y también espero leer feedback.

Por Sistema Operativo

Finalmente, agradezco a todos los lectores y espero que el contenido siga siendo relevante. Estoy seguro que el objetivo ecléctico hace que no todos los posts sean del mayor interés para todos, pero mientras que pueda canalizar algunas noticias o tendencias, me doy por hecho.

Como mencioné antes, me encantaría recibir feedback, para lo que pueden utilizar los comentarios o contactarme en Twitter (@CodeAndBeyond).

 

viernes, 4 de marzo de 2011

Joomla Buenos Aires 2011 (video)

Joomla BairesComunidad Joomla ha organizado el primer evento sobre esta plataforma en Buenos Aires, Argentina.

Joomla es un CMS (sistema de administración de contenidos) gratuito y de código abierto creado en PHP, y uno de los más populares del mundo. Es usado tanto por diseñadores o grupos no técnicos, gracias a la flexibilidad de configuración y la enorme cantidad de extensiones, como por desarrolladores que lo utilizan como plataforma.

Aunque en el mercado argentino también se lo utiliza con frecuencia, no se había hecho una reunión masiva todavía, y ha llegado el momento.

El evento es el lunes 14 de Marzo a las 18:40 hs en la UAI (Universidad Abierta Interamericana), sede central de Av. San Juan 983. En el sitio del evento hay instrucciones sobre cómo llegar.

Algo fuera de lo común para la comunidad PHP es el hecho de que Microsoft apoya el evento, y uno de los oradores será Drew Robbins, quien estará presentando WebMatrix, una herramienta para desarrollo web que soporta PHP y Joomla (además de otras plataformas).

Otro orador será Leandro D'Onofrio que presentará Joomla 1.6. También estará presente Gustavo Raúl Aragón, fundador de Comunidad Joomla, explicando como funciona el grupo (que abarca todo el mercado hispano-parlante) y las actividades que realizan.

Dejo un video introductorio de Joomla en español generado por la comunidad.

 

jueves, 3 de marzo de 2011

PyDay Córdoba 2011 (video del año pasado)

PyDay

PyAr, el grupo de usuarios de Python Argentina, sigue organizando sus jornadas sobre Python, como hizo el año pasado en Rafaela (Santa Fe) y Buenos Aires.

El 30 de abril próximo el evento estará en Córdoba, en la Universidad Tecnológica (UTN).

Como siempre el evento es gratuito pero hay que registrarse (las vacantes son limitadas, pero no ocupar lugar sin estar seguro, por favor) y quien quiera colaborar puede pagar por la emisión de un certificado, que sirve para cubrir parte de los costos.

La descripción del evento -directamente del sitio- dice:

El Python Day es un evento organizado por PyAr y dura un día donde se darán pequeños cursos y charlas relacionadas a este lenguaje que de a poco va a haciendo su lugar entre los desarrolladores. Tenemos como intención hacer un espacio en donde cualquier persona interesada pueda acercarse para preguntar, aprender y experimentar con estas herramientas.

Se puede ir viendo quienes están anotados para ir (varios sospechosos usuales de la comunidad Python ya figuran) en la página de participantes.

Y todavía no hay sesiones aceptadas, y se pueden proponer hasta el 1ero de abril, así que es una buena oportunidad para compartir experiencias.

Como ejemplo les dejo parte del programa de la jornada del año pasado en Buenos Aires:

Nivel Inicial

  • Python: Qué es y para que sirve
  • web2py: desarrollo web2.0 fácil y pythónico
  • Introducción a wxPython
  • import antigravity: 8 módulos útiles que probablemente no conocías
  • Como python puede mejorar tu productividad

Nivel Intermedio

  • Python 3000
  • Usando virtualenv e instanado librerias adicionales
  • OpenERP, sistema de gestión ERP y CRM desarrollado en Python
  • Entendiendo Unicode
  • XML con Python

Y finalmente, como otra muestra, dejo un video de la Introducción a Python a cargo de Ariel Rossanigo en el evento de Rafaela.

miércoles, 2 de marzo de 2011

Agile Open Buenos Aires - Calidad y Arquitectura

Agiles

El grupo Agiles.org de Argentina estará realizando el sábado 12 de marzo de este mes, en la sede Centro Cultural Borges de la Universidad Nacional de Tres de Febrero (Viamonte y San Martín, Capital Federal), un nuevo Agile Open sobre Calidad y Arquitectura.

De la página del evento en el sitio de Agiles:

Luego de los exitosos eventos Ágiles 2008, Ágiles 2009 y de los Agile Open Buenos Aires, Córdoba, Tandil, La Plata y Mar del Plata 2009, se organizará el evento Agile Open Buenos Aires 2011, enfocado en el tema de la Calidad y la Arquitectura en el desarrollo de software Agil.

Este evento servirá para la capacitación el intercambio de experiencias relacionadas con las técnicas y prácticas relacionadas a asegurar la calidad en el desarrollo de Software Ágil en organizaciones.

El evento como siempre es gratuito, pero requiere registración y las vacantes son limitadas (unas 70 personas).

El formato del evento es el de Open Space, por lo que no hay un temario predeterminado, sino que se construye al inicio con la postulación y votación de temas por parte de los asistentes, incluyendo la posibilidad de presentaciones, debates, actividades y otros formatos.

Dejo algunas fotos de otro Agile Open (en Córdoba), cortesía de mi amigo Pablo Rodríguez Facal.

Agile Open

Programa

¡Y no se olviden que en octubre se viene la conferencia anual Agiles 2011! (muy pronto más información).

martes, 1 de marzo de 2011

Mono 2.10 y las últimas novedades de la monada

Mono

Por si alguno de los lectores de este blog aún no lo sabe, Mono es la implementación abierta de .NET para Unix, Mac OS X y Windows.

El increíble equipo de Mono nunca se detiene, siempre acompañado por su líder Miguel de Icaza.

La última versión liberada es la 2.10 (en realidad la 2.10.1) mientras continúa el rumbo hacia el próximo gran lanzamiento, que será Mono 3.0.

Pero esta versión ya tiene grandes avances, como:

  • Soporte para el Google Native Client
    Esta es una tecnología que permite ejecutar código nativo dentro del browser de manera segura, y que ahora incluye no sólo la posibilidad de ejecutar código compilado previamente, sino también realizar compilación a demanda (JIT), lo que permite que Mono soporte Reflection.Emit o los lenguajes dinámicos, por ejemplo.
  • Nuevo motor de Profiling
    Este nuevo motor está optimizado para trabajar en entornos de múltiples hilos y es muy eficiente en todo sentido.
  • Implementación mejorada de Sockets
  • Mejoras en el Parallel Framework y en SGen, el nuevo recolector de basura (una increíble pieza de ingeniería)
  • Se unificó el runtime de soporte para MonoTouch y MonoDroid (versiones de Mono para IOs y Android respectivamente)
  • Cecil/Light es una versión mejorada de Cecil, la librería que permite generación e inspección de código en tiempo de ejecución, y que muchos utilizan incluso en .NET, donde no tiene un equivalente directo.
  • Nuevo mecanismo del compilador de C# y enormes mejoras en el shell interactivo
    Mientras Microsoft lleva más de dos años preparando su compilador como servicio, Mono lo tiene disponible desde entonces, incluyendo una consola que ahora permite no sólo la ejecución de expresiones sino de programas completos. El servicio de compilación además dejó de ser estático, con lo que se pueden crear diferentes instancias del compilador con contextos separados.
  • Compilador de VB que permite compilar a los perfiles de VB 2.0 al 4.0
  • Soporte completo para ASP.NET MVC 3 incluyendo Razor y WebPages. Mono 2.10.1 agregó algunos detalles que permiten ejecutar el CMS de código abierto Orchard de Microsoft, que de esta manera puede ejecutarse también en Linux.
  • Implementación de WebMatrix.Data, una librería de Microsoft que permite acceso a datos aprovechando los nuevos tipos dinámicos.
  • Muchísimas optimizaciones para Mono en OS X, que aprovechan más los servicios particulares del sistema operativo de Apple.
  • Compilador de F# e intérpretes de IronPython y IronRuby completamente integrados en los paquetes para Linux y Mac.
  • Gendarme 2.10, el analizador estático de Mono, también es mucho más rápido y tiene 33 reglas nuevas.

Como ven, nadie puede decir que Mono no avanza.

Para más detalles, se pueden ver las notas de los releases 2.10 y 2.10.1 en el sitio de Mono.

O pueden ir directamente a la página de descarga, donde encontrarán paquetes de instalación para Virtual PC, VMWare, LiveCD, openSUSE, SLES/SLED, Windows, Mac OS, CentOS, Solaris u otras distros de Linux.