March 2012 - Posts
Ayer tuve el gusto de asistir a mi segunda meetup de Ruby acá en Buenos Aires. Fue en Urban Station, un buen lugar para trabajadores móviles: pueden ir con su notebook y trabajar en una mesita, con WiFi, enchufe, pagando por hora, o alquilar salones chicos de reuniones. La gente de Ruby Argentina consiguió una sala con proyector. Llegué a las 18:20 (empeza 18:30), y me encontré con Esteban, arquitecto, programador PHP, que estaba en Ruby. Mientras esperábamos, aproveché para preguntarle por qué se usa en Arquitectura, me enteré de Build Information Modeling, ver mis enlaces http://delicious.com/ajlopez/bim. Tenía algo con ver con la charla que iba a dar, sobre AjLisp en Ruby (ver mis posts http://ajlopez.wordpress.com/category/ajlisp), porque AutoCad tuvo desde siempre AutoLisp como lenguaje de base de programación.
Poco a poco fue llegando más gente, como @soveran, @maceto, @inkel, creo que llegó @etagwerker pero no pude hablar con él.
El primer disertante fue… moi ;-). Presenté AjLisp en Ruby, ver https://github.com/ajlopez/AjLispRb. Hace dos días, encontré esta presentación:
How Emacs changed my life http://www.slideshare.net/yukihiro_matz/how-emacs-changed-my-life By Yukihiro "Matz", Ruby creator
Que me ayudó a poner la relación entre Lisp y Ruby. Conté algo de la historia de Lisp. Y destaqué que desarrollé AjLispRb usando TDD, desde el principio, para ir practicando y aprendiendo Ruby. Hice algunas demostraciones, mostrando rápidamente lambdas, define, closures y macros. Notablemente, cuando presenté que tiene una sintaxis tipo Java Dot Notation (ver http://jscheme.sourceforge.net/jscheme/doc/javadot.html) para acceder a objetos y clases Ruby, me preguntaron si esto anda en AjLisp:
(.require @Kernel "date”)
(.today @Date)
funcionó! ;-) Ni se me había ocurrido probarlo. En realidad, en vez de “@Kernel” puedo poner “pepe”, e igual termina invocando al método “global” require, tengo que investigar por qué. Jeje… AjLispRb tiene vida propia.
Luego presentó Michel Martens, gran programador Ruby, @soveran, y jugador de Go, ver https://github.com/soveran, por ejemplo, vean su framework web Cuba https://github.com/soveran/cuba. Presentó los elementos de uso de Rack, un tema que me interesa por su historia, relación con Python y otros. Ver mis enlaces http://delicious.com/ajlopez/rack. En un tiempo, quisiera preparar una charla corta sobre el tema, para algún Ruby Meetup u otro lugar.
Y notablemente, presentó algo muy interesante, Bandicoot:
http://bandilab.org/
http://www.readwriteweb.com/hack/2011/07/new-set-based-programming-language-bandicoot.php
Su presentación en:
http://files.soveran.com/bandicoot/ (hecha con https://github.com/nakajima/slidedown, ver https://github.com/soveran/slidedown-skeleton)
Interesante. Maneja conjuntos con operadores de álgebra relacional. Hmmm… interesante Code Kata para Pascual: implementar algo en C#, usando LINQ por debajo. Mis enlaces sobre el tema http://delicious.com/ajlopez/set+programminglanguages
Michel lo usó en un proyecto. Vean que Bandicoot levanta un servidor al que se accede por HTTP, y en su lenguaje se programa los “puntos de entrada” que se exponen por ese servidor HTTP. El escribió un cliente Ruby https://github.com/soveran/rel. También comentó sobre su parser de command line https://github.com/soveran/clap (vean el uso de lambdas de Ruby ahí).
Hubo otros temas que se trataron: el anuncio de Rails Girls en Buenos Aires:
http://railsgirls.com/buenosaires
Se propuso hacer un Ruby Camp, reunirse para programar, ya sea en un lugar abierto, o en un bar, o en una casa. Se anunció que ya se comenzó a organizar la Ruby Conf de 2012.
Se repartió “merchandising”, varios conseguimos una tarjeta de promoción de Code School http://www.codeschool.com/.
Un poco antes de las 21, se levantó la reunión que siguió con comida, bebida (supongo que agua mineral solamente ;-) en otros lugares de la zona de Palermo. Lo mío es la sopita de pollo, así que regresé a mi cubil principal.
Felicitaciones a la gente de Ruby Argentina por tener una comunidad tan activa y abierta.
Nos leemos!
Angel “Java” Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez
Estoy preparando una charla virtual (VAN) para Alt.NET Hispano, sobre varios lenguajes de programación (Clojure, Javascript, Erlang, Python, Ruby, Scala). Investigando sobre las comunidades de esos lenguajes, me encuentro con la página de la gente de Python Argentina:
http://python.org.ar/pyar
Ayer encontré ahí esta interesante propuesta en línea
Adopta a un newbie
Leo ahí
Me gusta que se documente lo que se vaya aprendiendo en un blog, así queda disponible la experiencia para otros. Ya conocía la idea de mentoring, que me parece excelente. Ver mis enlaces en:
http://delicious.com/ajlopez/mentoring
Recomiendo en especial:
The mentor manifesto
The Mentor Manifesto
- Be socratic.
- Expect nothing in return (you’ll be delighted with what you do get back).
- Be authentic / practice what you preach.
- Be direct. Tell the truth, however hard.
- Listen too.
- The best mentor relationships eventually become two-way.
- Be responsive.
- Adopt at least one company every single year. Experience counts.
- Clearly separate opinion from fact.
- Hold information in confidence.
- Clearly commit to mentor or do not. Either is fine.
- Know what you don’t know. Say I don’t know when you don’t know. “I don’t know” is preferable to bravado.
- Guide, don’t control. Teams must make their own decisions. Guide but never tell them what to do. Understand that it’s their company, not yours.
- Accept and communicate with other mentors that get involved.
- Be optimistic.
- Provide specific actionable advice, don’t be vague.
- Be challenging/robust but never destructive.
- Have empathy. Remember that startups are hard.
Desmystifying Mentoring
Myth #1: You have to find one perfect mentor
Myth #2: Mentoring is a formal long-term relationship
Myth #3: Mentoring is for junior people
Myth #4: Mentoring is something more experienced people do out of the goodness of their hearts
The importance of Trust and Mentorship for Startups
Pero me resultó novedoso que una comunidad en Argentina fomentara esta práctica. Sería interesante ver esto aplicado en otras comunidades, como Ruby Argentina, Alt.NET Hispano, o en grupos de usuarios como el MUG de Argentina.
También en empresas, consultoras, fábricas de software. Si Ud. va a proponer un programa así, recomendaría que fuera público, abierto, con cierto soporte de la consultora (tantas horas disponibles por persona), pero que sea emergente, no un programa formal. Es decir, que sea la gente la que se proponga como mentor o mentado en distintos temas. Eso permite ver quienes son más proactivos, y tienen ganas de compartir y aprender. Expone habilidades que quisiéramos tener en los miembros de nuestros equipos ágiles: curiosidad, capacidad de comunicación, inquietud, disciplina, etc.
Nos leemos!
Angel “Java” Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez
Este fin de semana, estuve trabajando en un intérprete Logo escrito en Javascript. Este es mi proyecto de código abierto eb:
https://github.com/ajlopez/AjLogoJs
Mi principal referencia del lenguaje fue el manuel de Berkeley:
http://www.cs.berkeley.edu/~bh/usermanual
Probé algunas expresiones en estas implementaciones en línea, también escritas en BLOCKED SCRIPT
http://logo.twentygototen.org/
http://www.calormen.com/Logo/
Sólo ejecuté expresiones, sin fijarme en el código de implementación. Prefiero primero escribir mi propia implementación, usando TDD en el proceso, desde cero, sin estar influido por alguna implementación anterior. El intérprete que escribí puede ejecutarse en el navegador y también en un servidor Node.js. En algún momento, podría agregar algún ejemplo del lado del servidor.
Inicialmente, pensé que necesitaba implementar un objeto List, pero los arreglos de Javascript fueron lo suficientemente buenos para implementar las listas de Logo. Durante la codificación, me dí cuenta que Javascript es un muy buen lenguaje de implementación para un intérprete Logo. Por ejemplo, Logo tiene una conducta interesante. Algo como:
print myproc 1 2 myotherproc 3 4
podría ser interpretado de diferentes maneras, dependiendo de la cantidad de parámetros que espera myproc o myotherproc. Cuando implementé procedimientos Logo primitivos como print, sum, make, etc… como funciones Javascript, la cantidad de argumentos que reciben me quedó disponible fácimente, con myfunc.length.
Cuando necesité ejecutar un bloque de Logo (un arreglo en Javascript, en mi implementación), pude usar una propiedad adicional, block.compile, para tener una versión compilada, ya lista, sin necesidad de compilar cada vez (esa propiedad es un cache del bloque compilado). Eso fue posible porque Javascript me permite agregar esa propiedad compiled a cualquier objeto. Es un lenguaje muy flexible.
Próximos pasos:
- Implementar soporte de paréntesis (p.ej. (sum 1 2 3 4) debería aceptar 4 argumentos, y retornar 10 como resultado)
- Operadores binarios infijos, como +, –, etc… Ahora tengo nombres como sum, difference, multiply, quotient, etc..
- Más predicados de comparación
- Soporte de listas de propiedades
- Tortuga sobre un canvas
Tengo planeado agregar:
- Soporte de Objetos, definiendo métodos como tobj move ant …. end, donde ant es el nombre del objeto prototipo/clase
- Acceso a objetos Javascript nativos, sus funciones y variables
Publiqué una versión online en
http://www.ajlopez.com/ajlogojs
Nos leemos!
Angel “Java” Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez
Hace unos días, migré mi proyecto AjTalk de Google Code a mi cuenta en GitHub:
https://github.com/ajlopez/AjTalk
Vengo trabajando en él, en mis tiempos libros, debe ser desde el 2008. Está escrito en C# e implementa una máquina virtual Smalltalk, basada en bytecodes. Codificado en C# plano, debería probarlo en otras plataformas, pero seguro que Mono lo soporta. En el 2011 le agregué la capacidad de compilar código Smaltalk de fileouts a Javascript, que se pueden usar tanto en el browser como en Node.js. El domingo pasado me decidí a crear otro proyecto:
https://github.com/ajlopez/AjTalkJs
como code kata del día. Tiene otro “approach”: implementar una máquina virtual AjTalk, desde 0, directamente en Javascript. La idea es compilar código Smalltalk a métodos y bloques con bytecodes, y tener el intérprete de esos método. Tanto la base del Lexer, Compiler, Block, Execution Block están funcionando. El código de la implementación principal está en:
https://github.com/ajlopez/AjTalkJs/blob/master/lib/ajtalk.js
En esa implementación, estoy usando un método sendMessage que usa un “custom lookup” para ubicar el método que atiende un mensaje, de acuerdo a su “selector”, su nombre. Un fragmento de lib/ajtalk.js:
BaseObject.prototype.sendMessage = function(selector, args)
{
var method = this.lookup(selector);
return method.apply(this, args);
};
function BaseClass(name, instvarnames, clsvarnames, supercls) {
this.name = name;
this.instvarnames = instvarnames;
this.clsvarnames = clsvarnames;
this.supercls = supercls;
this.methods = {};
};
BaseClass.prototype.__proto__ = BaseObject.prototype;
BaseClass.prototype.defineMethod = function (selector, method)
{
this.methods[selector] = method;
};
BaseClass.prototype.getInstanceSize = function() {
var result = this.instvarnames.length;
if (this.supercls)
result += this.supercls.getInstanceSize();
return result;
};
BaseClass.prototype.lookupInstanceMethod = function (selector)
{
var result = this.methods[selector];
if (result == null && this.supercls)
return this.supercls.lookupInstanceMethod(selector);
return result;
};
El lunes, se me ocurrió otra forma de hacerlo, que pensé que iba a tener dificultades: en vez de relegar la herencia a un “custom lookup”, podría aprovechar la cadena de prototipos para heredar métodos, e instancias por separado, para tener las variables de cada instancia. Escribí código en lib/ajtalknew.js:
function createClass(name, superklass, instvarnames, clsvarnames)
{
var protoklass = new Function();
if (superklass)
{
// Chain class prototypes
protoklass.prototype.__proto__ = superklass.proto;
}
else
{
// First class methods
protoklass.prototype.basicNew = function()
{
var obj = new this.func;
obj.klass = this;
return obj;
}
protoklass.prototype.defineSubclass = function(name, instvarnames, clsvarnames)
{
return createClass(name, this, instvarnames, clsvarnames);
}
protoklass.prototype.defineMethod = function(name, method)
{
var mthname = name.replace(/:/g, '_');
if (typeof method == "function")
this.func.prototype[mthname] = method;
else
this.func.prototype[mthname] = method.toFunction();
}
protoklass.prototype.defineClassMethod = function(name, method)
{
var mthname = name.replace(/:/g, '_');
if (typeof method == "function")
this.proto[mthname] = method;
else
this.proto[mthname] = method.toFunction();
}
// TODO Quick hack. It should inherits from Object prototype
protoklass.prototype.sendMessage = function(selector, args)
{
return this[selector].apply(this, args);
}
}
var klass = new protoklass;
// Function with prototype of this klass instances
klass.func = new Function();
klass.proto = protoklass.prototype;
klass.name = name;
klass.super = superklass;
klass.instvarnames = instvarnames;
klass.clsvarnames = clsvarnames;
klass.func.prototype.klass = klass;
if (superklass)
{
// Chaining instances prototypes
klass.func.prototype.__proto__ = superklass.func.prototype;
}
else
{
// First instance methods
klass.func.prototype.sendMessage = function(selector, args)
{
return this[selector].apply(this, args);
}
}
Smalltalk[name] = klass;
return klass;
}
createClass('Object');
Smalltalk.Object.defineClassMethod('compileMethod:', function(text)
{
var compiler = new Compiler();
var method = compiler.compileMethod(text, this);
this.defineMethod(method.name, method);
return method;
});
Smalltalk.Object.defineClassMethod('compileClassMethod:', function(text)
{
var compiler = new Compiler();
var method = compiler.compileMethod(text, this);
this.defineClassMethod(method.name, method);
return method;
});
Ok, es un poco “tricky” pero funciona!. Y ambos códigos fueron desarrollados con TDD, así que los refactors que hice fueron bien soportados y bienvenidos.
Esta vez, no usé QUnit para TDD en el browser. Usé línea de comando, con Node.js, y su “built-in” módulo assert (no tenía conexión a Internet cuando comencé a escribir, así que no me traje en NodeUnit). Es una experiencia interesante, porque fue la forma más simple de escribir tests: un largo programa con assert tras otro. Puedo en cualquier momento refactorizarlo, pero no ví que me complicara mucho en el desarrollo: avancé tan rápido como cuando escribo tests más organizados.
Tengo una función/”clase” javascript llamada Compilar que puede compilar código Smalltalk (un subconjunto de la gramática, por ahora) en bytecodes. Soporta mensajes unarios, binarios y de “keywords”. Sólo unos pocos bytecodes fueron necesarios para implementar la funcionalidad actual:
var ByteCodes = {
GetValue: 0,
GetArgument: 1,
GetLocal: 2,
GetInstanceVariable: 3,
GetGlobalVariable: 4,
GetSelf: 5,
SetLocal: 10,
SetInstanceVariable: 11,
SetGlobalVariable: 12,
Add: 20,
Subtract: 21,
Multiply: 22,
Divide: 23,
SendMessage: 40,
Return: 50
};
Hay ejemplos index.html, indexnew.html para probar interactivamente ambas implementaciones.
Trabajo pendiente: implementar variables de clases, metaclases, como siempre usando TDD. Mejorar los ejemplos de browser, y escribir posts sobre todo eso.
Nos leemos!
Angel “Java” Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez
Anterior Post
Siguiente Post
En el primer post de esta serie, expliqué el problema y el primer test, que va quedando en el repositorio del proyecto.
Veamos ahora el segundo test. Me decidí por probar que un domingo típico es día no laborable, que implica un cambio con respecto al anterior test. En el primer test que escribimos, preguntábamos por un caso positivo de día laborable. Ahora cambiamos a probar un caso negativo.
El nuevo test:
[TestMethod]
public void TypicalSundayIsANonWorkingDay()
{
WorkingDaysCalendar calendar = new WorkingDaysCalendar();
DateTime sunday = new DateTime(2012, 3, 11);
Assert.AreEqual(sunday.DayOfWeek, DayOfWeek.Sunday);
Assert.IsFalse(calendar.IsWorkingDay(sunday));
}
Al ejecutarlo, da rojo. El problema es que la actual implementación retorna que todos los días de la semana son laborables. El mínimo cambio en el código que hace que todo funcione es:
public bool IsWorkingDay(DateTime day)
{
if (day.DayOfWeek == DayOfWeek.Sunday)
return false;
return true;
}
Ahora sí funciona, habiendo agregado el if del comienzo. El próximo test que se me ocurre es probar que un sábado típico (más adelante veremos otros calendarios, por ejemplo, el de un peluquero, que acá en Argentina tienen como día no laborable el lunes, y muchos trabajan el sábado Y el domingo; era parte de los requerimientos, poder configurar el calendario). El tercer test, entonces, es:
[TestMethod]
public void TypicalSaturdayIsANonWorkingDay()
{
WorkingDaysCalendar calendar = new WorkingDaysCalendar();
DateTime saturday = new DateTime(2012, 3, 10);
Assert.AreEqual(saturday.DayOfWeek, DayOfWeek.Saturday);
Assert.IsFalse(calendar.IsWorkingDay(saturday));
}
Mínimo código que hace que el test pase a verde:
public bool IsWorkingDay(DateTime day)
{
if (day.DayOfWeek == DayOfWeek.Sunday || day.DayOfWeek == DayOfWeek.Saturday)
return false;
return true;
}
Agregué un día más no laborable en la condición del if.
Vean que quedaron dos constantes el código de implementación. Por ahora, no me preocupa. Es más: me parece que son constantes que reflejan algo básico del sistema que estamos armando, no son constantes arbitrarias. Comienza a surgir lo que entiendo como calendario típico: semana laborable, excepto sábados y domingo.
No hice mucho refactoring en estos test. Diferencias con el Coding Dojo: sigo usando nombres significativos para los tests (si hay que cambiarlos, los cambio). Tampoco usé métodos auxiliares que me devuelvan un lunes o un domingo o un sábado. Si necesito esos métodos, será porque surjan de refactor de código de tests (probablemente, si necesito obtener un lunes desde más de 2 tests, digamos).
Próximos pasos: ver qué es una semana típica, plasmarla en un test; comenzar a configurar el calendario (tal vez, sábado es laborable, para algunas profesiones, que usaran un calendario configurable para ellas).
Nos leemos!
Angel “Java” Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez
La semana pasada, el jueves 15 de Marzo, tuve el gusto de asistir a la (primera, creo) reunión del grupo Erlang Argentina, en las oficinas de Inaka Networks en Buenos Aires. El anfitrión principal fue el fundador de la empresa, el bueno de Chad Depue. Ver:
http://www.erlang-factory.com/conference/SFBay2010/speakers/ChadDePue (integrando Lua con Erlang)
Ahí encuentro Datos de 2010:
Chad DePue
Entrepreneur and creator of ErlangInside.com
Ruby Rescue
Chad DePue is a software developer and entrepreneur focusing on Ruby on Rails and Erlang through his consulting company Ruby Rescue. He is a former VP of Engineering at Visto Corporation (now Good Technologies) and started his career at Microsoft in the Developer Tools Division. In 2008 Chad moved his family to Buenos Aires, Argentina to, among other things, learn Spanish, a language which he finds much more difficult than Erlang.
Chad recently built a high-performance mobile payment and microlending platform in Erlang and Ruby on Rails, the combination of which he believes provides the rapid development time of Rails with the scalability, fault-tolerance, and easy-redundancy of the Erlang/OTP platform.
http://www.linkedin.com/in/depue
https://twitter.com/#!/chaddepue
@chaddepue
Developer from Seattle, Living in Buenos Aires, Argentina. I have a new consultancy called Inaka Networks focused on Ruby, iPhone, iPad, and Erlang applications
Buenos Aires, Argentina · http://inakanetworks.com
La empresa que fundó es Inaka, donde tienen desarrollos en Erlang, Ruby on Rails, Objective-C (para la programación cliente). Vean sus trabajos:
http://inakanetworks.com/projects/
donde en muchos usan Erlang para procesar concurrentemente mensajes de esas aplicaciones, con alto nivel de escalabilidad.
El lugar de encuentro fue en sus oficinas, calle Darwin al 1100, cerca de Av. Córdoba y J.B.Justo. Es un interesante edificio, que ocupa gran parte de la cuadra, y hasta tiene calles interiores. Antiguamente fue una fábrica de ropa de marca, y luego fue convertida en “loft” repartidos en varios cuerpos. Inaka ocupa uno de esos loft desde Enero de este año, son sus nuevas oficinas. Chad trabajó en Microsoft, Developer Tools, en Seattle, y habla bien español, con ocasionales consultas por algún vocablo. Así que no tuve que apelar a mi Anglish (Angel’s English) para hacerle preguntas. De curioso, conseguí esta información:
- Trabajó en Microsoft Developer Tools, con Visual Basic clásico, y llegó a trabajar también en Visual Basic.NET
- Su trabajo también tocaba Visual Interdev (los noventa… éramos tan pobres :-)
- Se mudó en 2008, a Argentina. Fue una decisión que tomó, junto con su familia (esposa, ahora 3 hijos), considerando: huso horario, idioma distinto del inglés, seguridad. Pensaban estar tres años, pero al fin se afincó con su nueva empresa acá.
- La empresa comienza a tener forma en 2010
Fui uno de los primeros en llegar a la reunión, donde fuimos recibidos por Chad, Fernando Benavides, Martina Freers (ver http://inakanetworks.com/people/). Sorpresa! Nos tenían preparadas cerveza, “snacks”, papa fritas… gnam! :-) Bueno, también había gaseosa, adivinen qué elegí para tomar.. :-)
Para este Erlounge (esta reunión) estaba previstas dos charlas. Una de Chad, sobre implementar un Redis en Erlang, vean:
https://github.com/inaka/edis (el tema me interesa, estoy implementando algo en C# https://github.com/ajlopez/AjKeyvs lo interesante para mí es cliente/servidor, implementación de las estructuras de datos, y espero llegar a sharding)
y otra de Fernando Benavides
sobre escalar Erlang, basado en el caso del proyecto:
https://github.com/inaka/match_stream
Son dos charlas que van a presentar ahora a fines de Marzo en Erlang Factory 2012. Pueden ver los slides de la charla de Fernando en https://github.com/inaka/erlang_factory
Los asistentes fuimos alrededor de veinte (no conté, a ojo de buen cubero), y fue interesante encontrar a gente en Argentina interesada en Erlang, y aún mejor, trabajando, con gran experiencia.
Le pregunté a Fernando sobre su historia con Erlang. Mi resultado de entrevista informal:
- Estudió en la Universidad de Buenos Aires, Ciencias Exactas (uy, recuerdo qué linda bibliote, que visitaba en los ochentas… #soytanviejo :-)
- Ahí vió que lo que le gustaba era la programación funcional
- Encontró un mensaje (en lista? en tablero de la facultad?) de una empresa, para trabajar en programación funcional
- En la universidad, vió Haskell, en la empresa se encontró con Erlang, y viene programando desde entonces (no tengo el año de inicio de su trabajo en esa empresa, Novamens)
- La empresa desaparece. Se va de vacaciones a Polonia, y ahí aprovecha y aplica para la certificación en Erlang.
- En septiembre de 2010 aparece un mensaje en la lista de Erlang Argentina, pidiendo programadores (era Chad Depue).
- Desde entonces trabaja en Inaka
Bueno, por hoy bastante. Próximos posts: comentarios de la charla de Fernando, y algunos de la charla de Chad (me tuve que ir a las 21hs, ya saben, lo mío es la sopita de pollo a la noche :-) y dormirme temprano).
Mientras, pueden ir leyendo:
http://inakanetworks.com/blog/2011/10/07/scale-test-plan-simple-erlang-application/
http://inakanetworks.com/blog/archives/
y ir viendo el código de GitHub https://github.com/inaka
Veremos cuándo se hace el próximo Erlounge. Quisiera dar una charla tipo “Erlang for dummies (like me!)”. Mis posts en Anglish sobre Erlang:
http://ajlopez.wordpress.com/category/erlang/
Mi pet project, pichón pichón de intérprete Erlang en C# https://github.com/ajlopez/ajerl (a ver si lo pongo como “commitment” para Abril).
Nos leemos!
Angel “Java” Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez
Siguiente Post
Comenté en el post Coding Dojo – TDD on the Rocks el ejercicio que hicimos en conjunto con el bueno de @HernanWilkinson. Quisiera hoy comenzar una serie explicando un poco mi estilo de programar ese ejercicio, para ir viendo las diferencias con lo visto en el coding dojo. No digo que sea mejor o peor, pero sí que es la forma en la que me siento más cómodo. Esta forma de encarar TDD (Test-Driven Development) la estoy publicando en
https://github.com/ajlopez/TddOnTheRocks/tree/master/MySrc
Pueden ver ahí el log de lo que fui escribiendo: estuve enviando commit al repositorio Git prácticamente por cada paso. Les recuerdo el problema:
- Calendario de días laborables y no laborables
- Se debe saber si una fecha particular es laborable o no
- Se debe configurar con:
- día de la semana no laboral (ej. Domingo)
- día de mes no laboral (ej. Primero de Enero)
- fecha particular no laboral (ej. 4 de Abril de 2012)
Primero, construí una solución en C# con Visual Studio, con dos proyectos: uno de librería de clases, y otro de test:
Vean que fui creando una clase para los tests, y otra clase para lo que quieron implementar. Ahí difiero del “approach” de @HernanWilkinson, que llamó a la clase de tests con un nombre no significativo. Yo prefiero empezar con un nombre más relacionado con el problema, aunque puede que después lo cambie.
El primer tests, para mí, es probar que los lunes, en general, son un día laborable. Este fue mi primer test:
[TestMethod]
public void TypicalMondayIsAWorkingDay()
{
WorkingDaysCalendar calendar = new WorkingDaysCalendar();
DateTime monday = new DateTime(2012, 3, 12);
Assert.IsTrue(calendar.IsWorkingDay(monday));
}
Acá otra “departure” del ejercicio del coding dojo. Mientras que aquel día codificamos el test poniéndole un nombre neutro como test1, yo prefiero darle un nombre significativo desde el principio, aunque después lo cambie. Me queda claro qué estoy intentando hacer, y también para cualquiera que lo vea. No me ha pasado con frecuencia que tenga que cambiar radicalmente el nombre a un test. Pueden ver los logs de proyectos de código abierto (por ejemplo los de GitHub), para notar que no he necesitado mucho el “renaming” de nombre de test.
Pero este test no compila. Armé una primera clase:
public class WorkingDaysCalendar
{
public bool IsWorkingDay(DateTime day)
{
throw new NotImplementedException();
}
}
que consigue que el test compile, pero al ejecutarlo, da rojo. El código mínimo que consiguió que pase a verde:
public bool IsWorkingDay(DateTime day)
{
return true;
}
No hay mucho lugar para hacer refactor, en este punto. Pero mejoré el código de test, para afirmar/controlar explícitamente que la fecha que estoy usando es un lunes:
[TestMethod]
public void TypicalMondayIsAWorkingDay()
{
WorkingDaysCalendar calendar = new WorkingDaysCalendar();
DateTime monday = new DateTime(2012, 3, 12);
Assert.AreEqual(monday.DayOfWeek, DayOfWeek.Monday);
Assert.IsTrue(calendar.IsWorkingDay(monday));
}
En el coding dojo usamos una función someSunday() (en este caso sería someMonday()), pero todavía no la necesité. Así que para mantener el test simple, me bastó crear una fecha de lunes directamente en el código del test. Para cualquiera que lea el test dentro de un año, me aseguro que la fecha elegida sea la de un lunes.
En el próximo post comentaré los siguientes tests que se me ocurrieron: probar que un domingo típico es no laborable, y que un sábado típico tampoco. Veremos cómo fue emergiendo la implementación interna, y al llegar a nuevos tests, cómo esta implementación fue siendo mejorada y refactorizada.
Jeje… “dog fooding”, el código de arriba fue “coloreado” con Acquarella.
Nos leemos!
Angel “Java” Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez
En el pasado fin de semana, encaré un “code kata” que necesitaba escribir. Estuve programando un “syntax highlighter” simple y configurable, en C#, llamado Acquarella. Pueden ver la historia, avance y resultado en:
https://github.com/ajlopez/Acquarella
La actual solución tiene una librería de clases, un programa de consola, y proyecto de tests:
La idea es tener una librería que podamos referenciar y usar desde nuestros proyectos, en caso que necesitemos algo de “syntax higlighting”, por ejemplo, en un convertidor de Markdown a HTML a la GitHub. La librería toma un texto (un string) e indicando el lenguaje de programación que contiene y el estilo que queremos darle, lo transforma en otro string, usando archivos de configuración. Hay algo más detalle en el README.md.
Practicando “Dog fooding”, el Token.cs transformado por Acquarella:
namespace Acquarella.Lexers
{
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
public class Token
{
private string text;
private int start;
private int length;
private TokenType type;
public Token(TokenType type, string text, int start, int length)
{
this.type = type;
this.text = text;
this.start = start;
this.length = length;
}
public string Value
{
get
{
return this.text.Substring(this.start, this.length);
}
}
public TokenType Type { get { return this.type; } }
public int Start { get { return this.start; } }
public int Length { get { return this.length; } }
}
}
Lindo! :-)
Trabajo pendiente: reconocer comentarios, números, algunos tipos de palabras adicionales (tengo que revisar otras implementaciones, GitHub distingue entre nombres, variables de instancias (si las reconoce en Ruby comenzando en @) y más), más estilos, y permitir extender el Lexer por código, si no basta la configuración.
Nos leemos!
Angel “Java” Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez
Ayer martes 13 de Marzo asistí a la reunión mensual de Agiles Buenos Aires. Fue un coding dojo sobre TDD, dirigido por el bueno de @HernanWilkinson. Pueden ver la descripción del evento en:
http://www.meetup.com/agiles-bsas/events/55342802/
En la reunión de marzo, Hernan Wilkinson facilitará un coding dojo en el que se trabajará sobre un ejercicio de programación para practicar diseño orientado a objetos y la utilización de TDD.
La idea es que todos podamos participar, por lo que usaremos la técnica de Coding Dojo, estilo Randori.
Venite preparado con tu laptop, con las baterias bien cargadas, con tu lenguaje preferido (Java, C#, Ruby, Smalltalk, etc.) y con muchas ganas de discutir, aprender y pasarla bien.
Fue una muy interesante reunión, donde aprendimos de TDD, pasos, refactoring, etc. Y hubo discusiones interesantes.
Hernán armó un coding dojo diferente, escribió en la lista del meetup:
La idea es que haya un proyector donde se ve que están haciendo los que pasan al frente y son dos. Cuando el que está con la computadora termina, toma la computadora el otro y pasa uno nuevo para ser el próximo que toma la posta. Lo único malo que tiene esta modalidad es que a veces la computadora que se usa no es cómoda para todos por el teclado o el lenguaje o ide no lo conocen todos, etc., lo que hace mas lento el desarrollo del ejercicio por eso para contrarrestar este problema es que vamos a hacer un "Randori" customizado :-), que consiste en que todos vayan con su laptop copiando lo que se está mostrando con el proyecto, cada uno con su lenguaje preferido, ide preferido, etc. y que cuando pasan al frente, pasan con su laptop y lo unico que hay que hacer es conectar la laptop al proyector. Además contrarrestar el problema que comenté, tiene la ventaja de que todos van a estar programando realmente y no siguiendo el ejercicio solo con los "ojos" y se va a poder ver cómo va quedando el mismo problema con distintos lenguajes. Se podría decir que la contra es que por ahí uno que sabe Java le costará entender a otro que lo hace en Ruby, pero el problema no es tan complicado como para que la diferencia entre los lenguajes haga difícil entender la solución que se desarrolla en cada uno de ellos. Creo que va a estar muy interesante y si funciona bien después lo patentamos!!
Felicitaciones a la organización (tengo que anotar quienes fueron sponsors), y en particular a Hernán, que supo manejar la sesión, muy interesante, informativa, y divertida. El trabaja en el día a día, con sus equipos, con TDD desde hace 10 años aprox. Así que tiene mucho para transmitirnos, la reunión de ayer fue el principio. Ya tengo pensado incorporar todo lo visto al Proyecto Hogwarts, veremos si tengo tiempo disponible.
Yo estuve desde el comienzo, hasta las 20:30hs, pero siguió la reunión. Asistieron más de veinte personas, muchas que asistían por primera vez a estas reuniones de Agiles@Buenos Aires. Nos repartimos en equipos de dos, para hacer pair-programming. (Uy! No pude anotar el nombre de mi compañero, salí apurado porque tenía que llegar temprano a otro lado). Trabajamos en C#, Visual Studio 2008, en la notebook que uso.
Fue muy interesante ver pasar equipos al frente, y discutir entre todos cuál era el próximo paso a implementar. Hubo gente de Java, C#, Ruby, en distintos sistemas operativos, IDEs y editores.
Hernán nos dió una guía de pasos a seguir (además de los clásicos de TDD: rojo, verde, refactor):
Pasos a seguir:
–Caso más simple “positivo”
–Caso negativo
–Caso concreto distinto
–Más de un caso concreto
–Casos bordes
–Pensar-:)
Hoy, Hernán publicó la presentación en:
http://www.slideshare.net/hernanwilkinson/tdd-on-the-rocks
(en el slide 4 están los pasos que mencioné antes).
El problema planteado fue:
- Calendario de días laborables y no laborables
- Se debe saber si una fecha particular es laborable o no
- Se debe configurar con:
- día de la semana no laboral (ej. Domingo)
- día de mes no laboral (ej. Primero de Enero)
- fecha particular no laboral (ej. 4 de Abril de 2012)
Publiqué lo que hizo mi equipo (hasta que me tuve que ir) en:
https://github.com/ajlopez/TddOnTheRocks
en el directorio Src. Traté de hacer commit por test, pero escribí rápido los comentarios.
Fue un muy interesante ejercicio. Estoy comenzando a escribir en https://github.com/ajlopez/TddOnTheRocks/tree/master/MySrc otro “approach” más alineado con lo que hago habitualmente para poder comparar las diferencias de énfasis en los dos estilos.
Nos leemos!
Angel “Java” Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez
A mitad de 2009, comencé a escribir una base de datos en memoria, como un ejercicio de C#. Ahora en estos días, retomé el trabajo en ese proyecto. Moví el código a mi GitHub:
https://github.com/ajlopez/AjBase
Tengo esta historia en Github:
La actual solución:
Como es lo usal, usé TDD para escribir. Todos los tests están en verde:
Los elementos principales por ahora implementados son:
Engine: Mantiene una lista de las bases de datos creads, que residen en memoria.
Database: Es el contendor de las tablas creadas.
Table: Una table tiene filas, y una RowDefinition.
RowDefinition: Maneja una lista de definiciones de columnas en una tabla.
Row: Mantiene los valores de las filas, cada celda es un objeto.
Tengo alguna duda: mantener un esquema definido (RowDefinition) por tabla, o ir por no tener esquema y manejar columnas libres (aún columnas diferentes en filas distintas de la misma tabla). Por ahora, voy a explorar el tener un esquema definido.
Hace poco, comencé a parsear comandos SQL. No es mi lenguaje preferido (tiene muchas variantes para ser elegante), pero el proyecto ya puede procesar los comandos más simples:
Quiero agregar un proveedor ADO.NET, ver el namespace Data:
Tengo una simple ADO.NET DbConnection, con algún soporte básico (incompleto) de ExecuteQuery, ExecuteNonQuery.
Próximos pasos: completar el proveedor ADO.NET, tener más soporte de SQL, y de concurrencia con transacciones (grandes desafíos! :-).
Próximos posts: ejemplos de creación de base de datos, crear una tabla, insertar datos, tanto por código como por comandos SQL. Mientras tanto, pueden explorar el código de los tests para tener una idea de cómo usarlo.
Nos leemos!
Angel “Java” Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez
En 2011, hice algo de investigación sobre el estado del arte en motores de reglas, especialmente en Java. Mis enlaces visitados:
http://delicious.com/ajlopez/ruleengine
Estuve leyendo sobre JBoss Drools Expert (ver http://delicious.com/ajlopez/drools). En diciembre, asistí a una Meetup del JBoss Group en Buenos Aires (ver post)
En los lejanos ochenta, me encontré con el algoritmo Rete (ver The Rete Matching Algorithm, Dr.Dobb's). Despues de toda esta investigación, decidí entretenerme escribiendo un motor de reglas en C#. Pueden seguir mi progreso en:
https://github.com/ajlopez/AjRools
La solución actual:
Como es usual, lo codifiqué usando TDD.
Tiene hechos (facts) que son afirmados, como por ejemplo Temperature = 38. Y tiene reglas (rules) que basadas en los hechos afirmados producen y afirman otros hechos. Tengo planeado agregar acciones que ejecuten código, además de afirmar nuevos hechos. Un ejemplo de regla:
# Rules example
rules
# Rule for Child Fever
rule
when
Temperature > 38
Age <= 12
then
HasFever is true
end
# Rule for Adult Fever
rule
when
Temperature > 37
Age > 12
then
HasFever is true
end
end
Tengo la idea de extender el motor a soportar objetos con propiedades, no solo variables simples:
rule
when
p is_a Patient
p.Temperature is 39
then
p.HasFever is true
end
pero esto está todavía en desarrollo. No adopté aún un algoritmo tipo Rete. Quiero tener primero una implementación que ejecute, con tests. Entonces, voy a mejorar la implementación interna (algo ingenua) para tomar en cuenta los cambios incrementales en la lista de hechos conocidos. Teniendo los tests, es un ejercicio de refactoring.
Trabajo pendiente: soporte de objeto con propiedades, sesión (un objeto que permita que un programa consuma un conjunto de reglas), etc.
Nos leemos!
Angel “Java” Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez
Primero, una revisión de mis resoluciones para Febrero:
- Implementar los primeros comandos ADO.NET en AjBase (in memory database) Completo
- Implementar Id y propiedades read/write en AjCoRe (simple Content Repository) Completo
- Comenzar a escribir AjComprobantes, aplicación simple PHP usando AjFwkPhp Completo
- Preparar una presentación sobre lenguajes de programación, a dictar en el MUG local Completo ver post
- Dar una presentación sobre AjLisp in Ruby en el meetup de Ruby Buenos Aires Meetup Completo
- Preparar una presentación sobre Clojure Parcial
- Escribir un REPL para AjLisp in Ruby Completo
- Más código de AjContab (a decidir si en PHP o .NET) Pendiente
- Templates en AjGenesis in Ruby Pendiente
- Agregar primer soporte de objetos en AjRools Expert Completo
- Agregar soporte de métodos con parámetros en AjLang Completo
- Post sobre mi trabajo en AjRools Completo
- Nuevo post sobre mi trabajo en AjLisp in Ruby Pendiente
- Post sobre mi trabajo en AjBase Completo
- Jugar con el REPL de Clojure Completo
- Post sobre Entendiendo Node.js (primero de una serie) Pendiente
- Post sobre Entendiendo Git (primero de una serie) Pendiente
Varios pendientes! Y también varios completos :-) El punto principal: el preparar la charla de lenguajes de programación (incluyendo Javascript sobre NodeJs, Scala, Clojure, Erlang, Python, Ruby) me tomó mucho tiempo (+- 40hs). Voy a ver si la amortizo repitiéndola en otros lugares. Tengo que revisar esa forma de preparación. Este mes, Marzo, será entonces dedica a escribir código, sin preparación de charlas, ni post en especial:
- Templates en AjGenesis in Ruby
- Soporte de control de flujo en AjLang
- Soporte de acceso a objetos nativos en AjLisp in Java
- Primeras estructuras, matching simple, un REPL simple para AjErl (erlang-like in C#)
- Primeras páginas web de AjContab, supongo simple ASP.NET MVC, con un dominio en memoria
- Mover AjPython a GitHub, revisando la implementación interna, revisar el alcance que quiero darle
- Mover AjSudoku a GitHub, y revisar el estado de tests y code coverage
- Comenzar el refactoring de la implementación interna de AjRools para ir pasando a un algoritmo más tipo Rete
- Comenzar el ingreso y proceso de facturas en AjComprobantes
Nos leemos!
Angel “Java” Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez
El jueves pasado tuve el gusto de dar una charla sobre lenguajes, en el Microsoft User Group de Argentina, en su sede de Buenos Aires. Mi idea era presentar lenguajes de programación, alguno nuevo, otros ya con más de 15 años de existencia, que la comunidad de programadores .NET o de tecnologías Microsoft no ve frecuentemente.
Para mí, es un tema interesante: ver que a lo largo del tiempo, en la historia de la computación, hay lenguajes de programación que aparecen, tiene éxito u olvido. Pasan los años, y seguimos teniendo nuevos lenguajes. Vean que en el ambiente de las computadoras personales, no ha pasado lo mismo con los sistemas operativos: prácticamente se estabilizó en dos opciones con variantes: Windows y Linux (y otros Unix no derivados de Linux directamente). Podría poner Mac OS como aparte también. En cambio, en el ámbito de los lenguajes de programación, sigue habiendo actividad de creación, y viejos lenguajes aún sobreviven (desde Fortran hasta COBOL, y Smalltalk, por poner ejemplos diversos). Y aparecen lenguajes nuevos cada año, como en el 2011 que vió nacer a Dart, de la mano de Google (que también se animó antes a crear el lenguaje Go).
Los lenguajes que presenté fueron:
- Javascript (en NodeJs)
- Scala
- Erlang
- Clojure
- Ruby
- Python (no alcanzó el tiempo, pero lo incluyo en este post)
Un punto que destaqué es que los primeros cuatro (Javascript/NodeJs, Scala, Clojure, Erlang) tratan, entre otros objetivos, de encarar el problema de paralelismo, y multithreading. Ante la desaceleración de la ley de Moore, se trata de aprovechar el hardware de computadoras multicore. Eso lleva a que los lenguajes tengan que soportar múltiples threads (tema que casi todos hoy soportan, de una u otra forma, aunque algunos sólo recientemente: Smalltak, Ruby tuvieron mucho tiempo implementados “green threads”, hilos simulados por el lenguaje, sin aprovechar los threads del sistema operativo, que explotan los múltiples recursos del hardware). Pero también lleva a la complicación: tenemos que escribir programas contenplando múltitples hilos de ejecución, concurrencia, condiciones de carrera, lockeos, etc. Veremos que Erlang (y Scala con Akka) lleva a un paso más: ejecutar en varias máquinas. Ese camino es muy interesante para mí, porque libera la restricción de tener que explotar solamente una máquina: para procesos pesados (desde web crawling, big data, etc...) podemos repartir el trabajo en varias máquinas “normales”. De hecho, vean cómo el mercado de las supercomputadoras ha ido decayendo, porque desde fines del siglo pasado se han encontrado soluciones basadas en clusters, grillas, etc... con varias computadoras atacando un problema.
También quería mostrar que estos lenguajes se pueden probar en Windows, sin grandes problemas de instalación. Muchos de estos lenguajes “nuevos y raros” nacen en ambientes Unix/Linux y no siempre su instalación en Windows fue fácil. Pero en estos tiempos, ya tenemos un buen soporte de Windows para los lenguajes que presenté.
De cada lenguaje mostré algún ejemplo simple, y otro ejemplo más complejo (aunque corto) que mostrara alguna característica destacada. Espero poder volcar todos los enlaces y comentarios hechos en este post. Comencemos.
Javascript/NodeJs
Sitio: http://nodejs.org/
Descripción, Historia: http://en.wikipedia.org/wiki/Nodejs http://en.wikipedia.org/wiki/JavaScript
Download que usé: el de Windows v0.6.7 pero pueden usar cualquiera de Windows 6.x. La actual es http://nodejs.org/dist/v0.6.12/node-v0.6.12.msi
Listas de Correo: http://groups.google.com/group/nodejs http://groups.google.com/group/nodejs-dev
Ejemplos que usé: https://github.com/ajlopez/NodeSamples
Mostré un servidor HTTP simplícimo, hello world asincrónico, y dibujar en canvas multiusuario, usando el módulo socket.io
Mis enlaces: http://delicious.com/ajlopez/nodejs
Mis posts: http://ajlopez.wordpress.com/category/nodejs/ http://msmvps.com/blogs/lopez/archive/tags/NodeJs/default.aspx
En especial:
Programando Juegos Sociales en Línea (Parte 8) Agregando Node.js
http://msmvps.com/blogs/lopez/archive/2012/01/12/social_2D00_games_2D00_programming_2D00_part_2D00_8_2D00_adding_2D00_node_2D00_js.aspx
AjFabriq en NodeJs (Parte 3) Una aplicación Distribuida Simple
http://msmvps.com/blogs/lopez/archive/2011/09/15/ajfabriq_2D00_on_2D00_nodejs_2D00_part_2D00_3_2D00_a_2D00_distributed_2D00_simple_2D00_application.aspx
Javascript aparece como lenguaje en el lanzamiento del Netscape Navigator de 1995 (éramos tan pobres :-). Fue desarrollado por Brendan Eich http://en.wikipedia.org/wiki/Brendan_Eich de Netscape, con el nombre Mocha (un gusto de café como también lo es la palabra “java”) y luego LiveScript.
Node.js es creado por Ryah Dahl de Joyent http://joyent.com/ Pueden ver un video de introducción en http://ajlopez.wordpress.com/2011/10/15/code-snippets-are-for-sissies/
Comentarios:
Node.js tiene un REPL (Read Eval Print Loop)
Corre sobre el motor de Javascript Google V8. Un motor muy rápido, pero orientado a tener un solo thread a nivel de Javascript (en las librerías internas de C usa threads). Node.js entonces implementa servidores (y código general, si uno quiere) que ejecutan un solo thread de Javascript. Con eso evita el problema de programar en múltiples threads. Pero entonces ¿qué ganamos? Todo Node.js (sus funciones de base, los módulos adicionales) se orienta a ejecución asincrónica. Por ejemplo, el thread principal puede pedir una consulta a una base de datos (usando un driver/módulo de Node.Js adecuado) SIN QUEDARSE esperando la respuesta. El thread principal sigue ejecutando. Cuando la consulta de base de datos tiene algún resultado, lo anuncia (en un sistema interno de eventos). El thread principal de Javascript está atendiendo esos eventos. La escalabilidad se logra aprovechando que la entrada/salida (a disco, red, etc.) se puede derivar asincrónicamente, sin ocupar el thread principal. Internamente, usa características de los sistemas operativos (como el soporte de select() en Linux, o los Completion I/O ports de Windows).
En el ejemplo de dibujo sobre canvas usando socket.io, usamos npm para instalar el módulo:
npm install socket.io
desde el directorio Server
Scala
Sitio: http://www.scala-lang.org/
Descripción e Historia: http://en.wikipedia.org/wiki/Scala_(programming_language)
Download: http://www.scala-lang.org/downloads yo usé http://www.scala-lang.org/downloads/distrib/files/scala-2.9.1.final.zip lo expandi y agregué el directorio bin al PATH
Ejemplos: https://github.com/ajlopez/ProgrammingLanguagesSamples/tree/master/Scala Ver los ejemplos de http://www.scala-lang.org/node/219
Hola mundo en: http://www.scala-lang.org/node/166
Ejemplos avanzados: http://www.scala-lang.org/node/44
Actores: http://www.scala-lang.org/node/242
El ejemplo ping pong: http://www.scala-lang.org/node/54
Lo ejecutamos con
scalac pingpong.scala
scala -cp . examples.actors.pingpong
Ejemplo de mensajes entre actores: http://www.scala-lang.org/node/50
Mis enlaces: http://www.delicious.com/ajlopez/scala
Mis posts: http://ajlopez.wordpress.com/category/scala/
Comentarios:
Es multiparadigma (soporta objetos/clases y programación funcional). Lenguaje de autor, creado principalmente por Martin Odersky http://en.wikipedia.org/wiki/Martin_Odersky Compila a Java y permite reducir la ceremonia (por ejemplo, soporte de declarar directamente un objeto único, sin necesidad de declarar clase). Soporta actores, ejemplo que mostré en la charla. Con actores, Scala evita que el programador tenga que encargarse de los lockeos y manejo de múltiples threads.
Sobre actores ver: http://delicious.com/ajlopez/actormodel http://en.wikipedia.org/wiki/Actor_model
y también message passing: http://en.wikipedia.org/wiki/Message_passing
Ver el proyecto Akka, que extiende Scala a actores distribuidos: http://akka.io/
Clojure
Sitio: http://clojure.org/
Descripción e Historia: http://en.wikipedia.org/wiki/Clojure
Download: Ver http://clojure.org/downloads Yo usé http://repo1.maven.org/maven2/org/clojure/clojure/1.3.0/clojure-1.3.0.zip y también la versión 1.2.0
Listas de Correo: http://groups.google.com/group/clojure
Comentarios:
Vimos cómo Clojure es un dialecto de Lisp, y tiene homoniconicity http://en.wikipedia.org/wiki/Homoiconicity . Compila internamente a Java, y hay una versión para CLR (Common Language Runtime de .NET). Mostré en el ejemplo de Game of Life http://www.youtube.com/watch?v=CFCYVfApPUc http://github.com/sfraser/MultithreadedGameOfLife el uso de Software Transactional Memory, ver http://en.wikipedia.org/wiki/Software_transactional_memory que es una de las formas que tiene Clojure de “atacar” el problema de la concurrencia.
Para probar Clojure en línea ver http://tryclj.com/
Ver http://java.ociweb.com/mark/stm/article.html sobre STM
Erlang
Sitio: http://www.erlang.org/
Descripción e Historia: http://en.wikipedia.org/wiki/Erlang_(programming_language)
Download: http://www.erlang.org/download.html Yo usé http://www.erlang.org/download/otp_win32_R15B.exe
Ejemplos: http://pragprog.com/titles/jaerlang/source_code del libro de Joe Armstrong Programming Erlang http://pragprog.com/book/jaerlang/programming-erlang Ejemplos más sencillos: https://github.com/ajlopez/ProgrammingLanguagesSamples/tree/master/Erlang a ir actualizando.
Primeros pasos: http://www.erlang.org/static/getting_started_quickly.html
Comunidad en Argentina: http://erlang.org.ar/
Lista de Correo de Argentina: http://erlang.org.ar/ListaDeCorreo
Comentarios:
Vimos que Erlang es un lenguaje funcional: no hay variables, una vez ligada una “variable” a un valor, no se puede modificar. Todas son funciones. Tenemos varios procesos. Vimos el ejemplo key value store (kvs.erl) del libro de Joe Armsgrong.
Ejecutamos en el REPL erl:
c(kvs).
kvs:start().
kvs:store(apple, 10).
kvs:lookup(apple).
Luego vimos de lanzar DOS cajas de DOS. En una:
erl -sname galdalf
c(kvs).
kvs:start().
en la otra ejecutamos:
erl -sname bilbo
rpc:call(gandalf@localhost, kvs, store, [apple, 10]).
rpc:call(gandalf@localhost, kvs, lookup, [apple]).
Caso de éxito http://couchdb.apache.org/ NoSQL reescrito en Erlang.
Post http://ajlopez.wordpress.com/2011/08/24/erlang-links-news-and-resources-1/
Mis enlaces: http://delicious.com/ajlopez/erlang
http://lambda-the-ultimate.org/node/4453 Long rant on Erlang-style Actors: Lost Dimension
Vean el lenguaje E:
http://erights.org/index.html
http://wiki.erights.org/wiki/Walnut
http://erights.org/talks/thesis/index.html
Ruby
Sitio: http://www.ruby-lang.org/en/
Descripción e Historia: http://en.wikipedia.org/wiki/Ruby_(programming_language)
Download: http://www.ruby-lang.org/en/downloads/ Yo usé http://rubyinstaller.org/downloads/ Revisar mis posts sobre detalles de instalación importantes, como el DevKit. Y tambien http://delicious.com/ajlopez/ruby+install
Mis posts: http://ajlopez.wordpress.com/category/ruby http://msmvps.com/blogs/lopez/archive/tags/ruby/default.aspx donde explico paso a paso instalación de Ruby, Rails, y un primer sitio Rails. Y también mi experiencia en el último Ruby Meetup de Buenos Aires.
Mis enlaces: http://delicious.com/ajlopez/ruby
Comunidad en Argentina: http://ruby.com.ar/
Conferencia 2011: http://rubyconfargentina.org/en
Lista de Correo Argentina, Latinoamérica: http://groups.google.com/group/rubysur
Sitio: http://rubysur.org/
Python
Sitio: http://python.org/
Descripción e Historia: http://en.wikipedia.org/wiki/Python_(programming_language)
Download: Hay dos versiones, usé http://python.org/ftp/python/2.7.2/python-2.7.2.msi y también tenía instalado http://python.org/ftp/python/3.2.2/python-3.2.2.msi Pero sólo la última instalación está ligada a ejecutar automáticamente los archivos .py, ver http://stackoverflow.com/questions/3809314/how-to-install-both-python-2-x-and-python-3-x-in-windows-7
Ejemplos simples: https://github.com/ajlopez/ProgrammingLanguagesSamples/tree/master/Python
Comunidad en Argentina: http://python.org.ar/pyar/
Lista de Correo en Argentina: http://listas.python.org.ar/listinfo/pyar
Vean el video anunciando la próxima PyCon http://animoto.com/play/zVp1IGeGaLVKco0FDlwcmA
Mostré Django
https://www.djangoproject.com/
https://docs.djangoproject.com/en/1.3/topics/install/#installing-official-release
C:\Software\Django-1.3.1
https://docs.djangoproject.com/en/1.3/intro/tutorial01/
Ver también
IronPython (Python running on .NET)
Jython (Python running on the Java Virtual Machine)
PyPy (A fast python implementation with a JIT compiler)
Stackless Python (Branch of CPython supporting microthreads)
Ver la implementación web: http://webpython.codepoint.net/wsgi_tutorial madre de otras implementaciones como Rack en Ruby, y OWIN en .NET
Mis enlaces: http://delicious.com/ajlopez/python
Mis posts: http://ajlopez.wordpress.com/category/python/
Patrones encontrados
Existencia de REPL: todos
Compilación a otro lenguaje: Scala, Clojure, usando la máquina virtual y librerías de clases existentes
Pasaje de Mensajes: Erlang
Módulos: todos
Actores: Scala, algo también en Clojure y Erlang
Software Transactional Memory: Clojure
Bueno, espero que les haya dado un panorama de que hay vida más allá de C# y Java ;-)
Nos leemos!
Angel “Java” Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez