viernes, 25 de febrero de 2011

Brunch: aplicaciones HTML5 desde los hombros de gigantes

Brunch

"Parado sobre los hombros de gigantes" es una frase típica de la cultura anglosajona, famosamente usada por Isaac Newton, que refiere a construir sobre el trabajo de quienes nos han precedido.

Esta idea es la base de Brunch, un framework compuesto de varias partes preexistentes para facilitar la construcción de aplicaciones web modernas.

Incluso si uno no va a usarlo directamente, es bueno recorrer y entrar en contacto con algunos de sus componentes, todos ellos de código abierto, no todos tan conocidos. Veamos cuáles son:

  • CoffeeScript
    Es un lenguaje que compila a Javascript, simplificando mucho la sintaxis, como se puede leer en este post previo.
  • Backbone.js
    Es una librería para aplicaciones JavaScript que brinda estructura para utilizar modelos y vistas con eventos de uso declarativo, un API para colecciones con mucha funcionalidad, y capacidades de conexión utilizando JSON con interfaces REST. Pueden ver un ejemplo en línea con el código completamente documentado a un link de distancia.
  • Underscore.js
    Es otra librería, que Backbone utiliza, y que provee más funciones para manejo de estructuras de datos a mas bajo nivel, incluyendo colecciones, arrays,  extensión sobre funciones (como memorización, diferimiento, composición, etc), objetos, utilidades y cadenas.
  • Eco
    Es un motor de plantillas que permite embeber CoffeScript dentro del markup de una página, como si fuese EJS o ERB.
  • Stylus
    Es un lenguaje de declaración de hojas de estilo en cascada (CSS) con una sintaxis simplificada, como CoffeScript hace con JavaScript. Es básicamente CSS sin llaves ni otros signos de puntuación, mucho más legible.
  • Docco
    Genera documentación de código en formato HTML, soportando Markdown y colorero de sintaxis. Unos cuantos de los proyectos anteriores utilizan Docco en su documentación.
  • jQueryZepto.js
    jQuery no requiere presentación para los lectores de este blog, pero Zepto es un framework minimalista compatible con jQuery y orientado a navegadores de dispositivos móbiles basados en WebKit.

En suma, más allá de Brunch mismo, puede verse un ecosistema creciente de librerías que trabajan en conjunto y con buen nivel de compatibilidad.

 

jueves, 24 de febrero de 2011

Festejando los 20 años de Python con la versión 3.2

Pyton

La mejor imagen de la celebración es el tweet de hace unos días del creador de Python, Guido van Rossum:

Guido Tweet

En nuestra industria 20 años parecen dos o tres generaciones de lenguajes, y Python sigue demostrando su relevancia y popularidad.

Mientras que la versión 2.7 será probablemente la última importante de la línea 2.x, la rama 3.x empieza a tomar más impulso.

Siguiendo la PEP 3003, que declaró una moratoria para los cambios en el lenguaje, no hay cambios sintácticos en esta versión tampoco, y las mejoras se concentran en librerías y portabilidad desde 2.x.

Algunas de las principales novedades son:

  • mejoras en el módulo unittest (varias provenientes del amigo Michael Foord)
  • una nueva librería para programación concurrente
  • un GIL mejorado que reduce la contención (uno de los temas más problemáticos de Python en su historia)
  • manejo extendido de mails
  • mejor soporte para SSL incluyendo contextos y comparación de certificados
  • un módulo para acceder a información de configuración
  • mejoras al depurador pdb

Pueden leer (en inglés) el detalle completo de la versión, o la lista detallada de las novedades.

 

miércoles, 23 de febrero de 2011

Ruby Enterprise Edition y las mentes detrás (video)

Phusion

La gente de Phusion acaba de lanzar una versión actualizada de Ruby Enterprise Edition.

¿De qué se trata? Estos muchachos (Ninh Bui, Hongli Lai y Tinco Andringa) llevan bastante tiempo trabajando en Ruby on Rails, muchas veces en proyectos muy exigidos, y encontraron varios de los problemas más importantes de Ruby (1.8, básicamente) pero en vez de quejarse, con el mejor espíritu de la comunidad de código abierto, crearon un fork donde arreglaron varios de las principales preocupaciones del motor al usarlo en instalaciones de Rails de gran escala.

Para que quede claro, esta distribución está pensada para instalaciones en servidores, y sigue siendo código abierto y gratuito.

La diferencia principal contra el motor de Ruby 1.8 (aunque en 1.9.x muchos de estos temas mejoraron drásticamente) está alrededor del recolector de basura, que logra reducir el uso de memoria de las aplicaciones Rail en un promedio del 33%, y a la vez incluye un mecanismo optimizado de alocación de memoria que aumenta mucho el rendimiento.

Algunos de los usuarios más conocidos de esta distribución son el New York Times, Twitter, Shopify y 37signals (esta última la empresa de David Hienemeier Hansson, el creador de Rails).

Algo muy interesante es que todo esto se logró a través de pura ingeniería aplicada a mejorar proyectos existentes, y el equipo de Phusion lo usa como base de su trabajo de consultoría, pero lo comparte con la comunidad en general.

Dejo debajo el video de Hongli Lai explicando las optimizaciones que hicieron durante un Google Tech Talk (charlas que organiza Google para sus empleados y comparte en video con el resto del mundo).

Al video está en inglés, pero lo que puede resultar más complicado es seguir los detalles técnicos, que no son aptos para principiantes.

martes, 22 de febrero de 2011

SADIO organiza la 40va edición de las JAIIO

SADIO

(luego de un receso vacacional, este blog vuelve a la carga)

En estos días me llegó el boletín de SADIO, la sociedad decana de nuestra área en Argentina, con más de 50 años de trayectoria. Me parece una buena ocasión para hacer eco de una de sus principales actividades.

40 JAIIO

Este año volverán como siempre las jornadas argentinas de informática. La edición número 40 (arrancaron en 1961) se llevará a cabo del 29 de agosto al 2 de septiembre en la UTN de Córdoba, Argentina.

La descripción de las jornadas, según los organizadores mismos, es:

En sesiones paralelas se presentan trabajos que se publican en Anales, se discuten resultados de investigaciones y actividades sobre diferentes topicos, desarrollandose también conferencias y reuniones con la asistencia de profesionales argentinos y extranjeros. Las JAIIOs se organizan como un conjunto de simposios separados, cada uno dedicado a un tema específico, de uno o dos días de duración, de tal forma de permitir la interacción de sus participantes.

Como siempre hay amplia variedad de simposios, incluyendo:

  • ASAI 2011 - Simposio Argentino de Inteligencia Artificial
  • ASSE 2011 - Simposio Argentino de Ingeniería de Software
  • AST 2011 - Simposio Argentino de Tecnología
  • CAI 2011 - Congreso Argentino de AgroInformática
  • CAIS 2011 - Congreso Argentino de Informática y Salud
  • HPC 2011 - High Performance Computing
  • JII 2011 - Jornadas de Informática Industrial
  • JSL 2011 - Jornadas Argentinas de Software Libre
  • JUI 2011 - Jornadas de Vinculación Universidad-Industria
  • SID 2011 - Simposio Argentino de Informática y Derecho
  • SIE 2011 - Simposio de Informática en el Estado
  • SIO 2011 - Simposio Argentino de Investigación Operativa
  • SSI 2011 - Simposio sobre la Sociedad de la Información
  • WSegI 2011 - Workshop de Seguridad Informática
  • EST 2011 - Concurso de Trabajos Estudiantiles

Para los interesados en proponer trabajos para cualquiera de estos simposios, ya está abierta la recepción, que cierra el 2 de mayo. Para comprender bien el proceso de presentación (necesario por el enorme volumen de presentaciones), lo ideal es seguir las instrucciones detalladas en la página de cada simposio (por ejemplo, la del de Ingeniería de Software). Implica crear primero credenciales individuales (si no se presentó un trabajo previamente en otras JAIIO), y luego hacer la presentación de la o las propuestas.

Dejo un breve video mostrando el mecanismo para la edición pasada, ya que el proceso sigue siendo igual.

 

 

sábado, 12 de febrero de 2011

[Video y Ejercicio] Agiles @ Buenos Aires: Coding Dojo

Agiles.org

La semana pasada se realizó la reunión mensual de Agiles @ Buenos Aires, como anuncié en un post anterior.

No voy a repetir todo el detalle, sino a dejar el video de la introducción de Adrián Eidelman, y el arranque del ejercicio con el primer par frente a la computadora.

El resto se los ahorro porque son dos horas en las que no se llega a leer claramente el código y la conversación entre los pares no llega a distinguirse claramente. Es un tipo de actividad que requiere presencia directa para disfrutarla, y recomiendo que estén atentos si les interesa porque ya hay en marcha una iniciativa de Katayunos (desayunos entre tres o cuatro personas para practicar Code Katas), y cualquiera puede organizar algo así con sus compañeros de trabajo o de estudio.

Pero para que no se pierdan el total (aunque la gracia es el camino recorrido más que el punto final), dejo el ejercicio tal cuál como quedó resuelto durante la reunión (sin edición ni retoque), cortesía de Adrián. La plataforma y lenguajes son anecdóticos, pero en este caso se realizó en C# utilizando Visual Studio 2010 y NUnit como framework de testing.

Van primero los tests (un primer ejercicio puede ser tomar los tests y tratar de escribir el código sobre ellos):

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Moq;
using NUnit.Framework;
using NumerosRomanos;

namespace NumerosRomanos.Tests
{
    [TestFixture]
    public class Tests
    {
        Conversor conversor;

        Dictionary<int, string> valores;

        [TestFixtureSetUp]
        public void setUp()
        {
            conversor = new Conversor();
            valores = new Dictionary<int, string>();
            valores.Add(1, "I");
            valores.Add(5, "V");
            valores.Add(10, "X");
            valores.Add(50, "L");
            valores.Add(100, "C");
            valores.Add(500, "D");
            valores.Add(1000, "M");
        }

        [Test]
        [ExpectedException(typeof(ArgumentException))]
        public void El0ArrojaExcepcion()
        {
            int numeroArabigo = 0;

            string numeroRomano = conversor.ANumerosRomanos(numeroArabigo);
        }

        [Test]
        [ExpectedException(typeof(ArgumentException))]
        public void NumeroNegativoArrojaExcepcion()
        {
            int numeroArabigo = -1;

            string numeroRomano = conversor.ANumerosRomanos(numeroArabigo);
        }

        [Test]
        [ExpectedException(typeof(ArgumentException))]
        public void El4000ArrojaExcepcion()
        {
            int numeroArabigo = 4000;

            string numeroRomano = conversor.ANumerosRomanos(numeroArabigo);
        }

        [Test]
        public void El1DeberiaDevolverI()
        {
            int numeroArabigo = 1;

            string numeroRomano = conversor.ANumerosRomanos(numeroArabigo);

            Assert.AreEqual("I", numeroRomano);
        }

        [Test]
        public void El5DeberiaDevolverV()
        {
            int numeroArabigo = 5;

            string numeroRomano = conversor.ANumerosRomanos(numeroArabigo);

            Assert.AreEqual("V", numeroRomano);
        }

        [Test]
        public void El10DeberiaDevolverX()
        {
            int numeroArabigo =10;

            string numeroRomano = conversor.ANumerosRomanos(numeroArabigo);

            Assert.AreEqual("X", numeroRomano);
        }

        [Test]
        public void El2DeberiaDevolverII()
        {
            int numeroArabigo = 2;

            string numeroRomano = conversor.ANumerosRomanos(numeroArabigo);

            Assert.AreEqual("II", numeroRomano);
        }

        [Test]
        public void El3DeberiaDevolverIII()
        {
            int numeroArabigo = 3;

            string numeroRomano = conversor.ANumerosRomanos(numeroArabigo);

            Assert.AreEqual("III", numeroRomano);
        }

        [Test]
        public void El15DeberiaDevolverXV()
        {
            int numeroArabigo = 15;

            string numeroRomano = conversor.ANumerosRomanos(numeroArabigo);

            Assert.AreEqual("XV", numeroRomano);
        }

        [Test]
        public void El4DeberiaDevolverIV()
        {
            int numeroArabigo = 4;

            string numeroRomano = conversor.ANumerosRomanos(numeroArabigo);

            Assert.AreEqual("IV", numeroRomano);
        }
        [Test]
        public void El48DeberiaDevolverXLVIII()
        {
            int numeroArabigo = 48;

            string numeroRomano = conversor.ANumerosRomanos(numeroArabigo);

            Assert.AreEqual("XLVIII", numeroRomano);
        }

        [Test]
        public void RetornaValoreConocidos()
        {
        
            foreach(var i in valores.Keys)
                Assert.AreEqual(valores[i], conversor.ANumerosRomanos(i));

        }
    }
}

Y aquí está finalmente la implementación misma (para quienes quieran hacer trampa):

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace NumerosRomanos
{
    public class Conversor
    {
        List<int> valoresArabigos = new List<int> 
            {1,4,5,9,10,40,50,90,100,400,500,900,1000};
        List<string> valoresRomanos = new List<string> 
            {"I","IV","V","IX","X","XL","L","XC","C","CD","D","CM","M"};
    
        public Conversor()
        {
            valoresArabigos.Reverse();
            valoresRomanos.Reverse();
        }

        public string ANumerosRomanos(int numeroArabigo)
        {
            if (numeroArabigo<=0 || numeroArabigo>3999)
                throw new ArgumentException();


            string resultado="";

            while (numeroArabigo > 0)
            {
                foreach (var i in valoresArabigos)
                {
                    if (i <= numeroArabigo)
                    {
                        resultado += valoresRomanos[valoresArabigos.IndexOf(i)];
                        numeroArabigo -= i;
                    }
                }
            }

            return resultado;
       }
    }
}