Ayer, 20 de Mayo, tuve el gran gusto de presentar un tema que me gusta mucho, la implementación de lenguajes de programación, y en este caso, usando Javascript como lenguaje destino. Fue en la JSConf Argentina 2012:
http://jsconf.com.ar/
(Ya había escrito un post anunciando la conferencia) El día fue excelente, llena de interesantes charlas, muy bien organizada por @rauchg y su equipo (creo de @vulsai), tomé muchas notas, espero escribir uno o dos posts sobre el tema, en cuanto me recupere ;-) Mientras, pueden leer el post de @aijoona
http://blog.aijoona.com/2012/05/21/jsconf-ar-2012-mi-resumen/
Como ejemplo de charla, vean la de WebGL para javascripters de @gerbille:
http://www.slideshare.net/gerbille/webgl-para-javascripters
Este post contiene los enlaces y las implementaciones que visité y preparé para la charla, que tuvo poco de gráfico, y mucho, mucho de código. Debería comenzar a usar los lenguajes que presenté, para manejar temas gráficos en el cliente, por ejemplo WebGL, SVG, tal vez usar d3.js.
Mi presentación en mi Skydrive (nota: tengo que escribir la próxima presentación mía, supongo que será en el Ruby Meetup, en markdown y publicarla en HTML).
Lista de lenguajes que compilan a Javascript
https://github.com/jashkenas/coffee-script/wiki/List-of-languages-that-compile-to-JS
The JavaScript World Domination Plan at 16 Years
http://www.infoq.com/presentations/The-JavaScript-World-Domination-Plan-at-16-Years
Lisp as the Maxwell’s equations of software
http://www.michaelnielsen.org/ddi/lisp-as-the-maxwells-equations-of-software/
A Conversation with Alan Kay
http://queue.acm.org/detail.cfm?id=1039523
The Magnificent Seven
by Michael Fogus
http://fogus.me/static/preso/magnificent7/#slide1
McCarthy's Lisp in Python with macros
https://github.com/fogus/lithp
The roots of Lisp
http://www.paulgraham.com/rootsoflisp.html
Presenté AjLisp en Javascript
https://github.com/ajlopez/AjLispJs
Comenté y mostré demo de AjLogo en Javascript
https://github.com/ajlopez/AjLogoJs
Demo http://ajlopez.github.com/AjLogoJs/demo.html
Otras implementaciones de Logo en Javascript
http://www.calormen.com/Logo/
http://logo.twentygototen.org/
Recomendé ver a NetLogo http://ccl.northwestern.edu/netlogo/ (en Java) para ver hasta dónde ha llegado el tema.
Hice correr el REPL y el compilador de Clojurescript
https://github.com/clojure/clojurescript
Presenté a la AjTalk VM en C#, y desde el año pasado compila Smalltalk a Javascript
https://github.com/ajlopez/AjTalk
Este año agregué AjTalk en Javascript, con VM en bytecodes, y ejecutor de métodos compilados con AjTalk
https://github.com/ajlopez/AjTalkJs
Demo http://ajlopez.github.com/AjTalkJs/demo.html
Mostré una simple demo de clases Smalltalk compiladas a Javascript, que manejan google, y google.earth.
Levanté Amber y comenté cómo en su definición de métodos ponen Javascript nativo
http://amber-lang.net/
Visité la página de Smalltalk S8, U8
http://u8.smalltalking.net/
http://u8.smalltalking.net/browsecontributions.aspx
No pudimos ver las demos, justo en ese momento estuve sin conexión. Les comento algunos enlaces. Veamos dos:
Hay una Smalltalk S8 Console (con una compilación de V8 preparada para levantar código st)
http://u8.smalltalking.net/profile/smalltalking/125/index.html
Ver sus demos de Google Earth
http://u8.smalltalking.net/contribution.aspx?contributionId=222
(exploren las clases, creo que eran Google, GoogleEarth, GoogleEarthObject, GEDemo, etc…)
Mis posts sobre AjTalk, AjLisp, AjLogo implementations
http://ajlopez.wordpress.com/category/ajtalk/
http://ajlopez.wordpress.com/category/ajlisp/
http://ajlopez.wordpress.com/category/ajlogo/
http://msmvps.com/blogs/lopez/archive/tags/AjLisp/default.aspx
http://msmvps.com/blogs/lopez/archive/tags/AjLogo/default.aspx
http://msmvps.com/blogs/lopez/archive/tags/AjTalk/default.aspx
Mis posts sobre Javascript
http://msmvps.com/blogs/lopez/archive/tags/Javascript/default.aspx
Les agrego algunos enlaces sobre ClojureScript, que no mencioné
Introducing ClojureScript
http://clojure.com/blog/2011/07/22/introducing-clojurescript.html
de @stuartsierra
ClojureScript Rationale
https://github.com/clojure/clojurescript/blob/master/devnotes/cljs.org
de @stuarthalloway
Compiling Clojure to Javascript pt. 1 of n
http://blog.fogus.me/2011/07/21/compiling-clojure-to-javascript-pt1/
de @fogus
Ferret: An Experimental Clojure Compiler
http://nakkaya.com/2011/06/29/ferret-an-experimental-clojure-compiler/
Los enlaces que me interesaron, leí, estudié para esta charla, o los tengo pendientes:
http://delicious.com/ajlopez/clojurescript
http://delicious.com/ajlopez/javascript+parser
http://delicious.com/ajlopez/javascript+compiler
http://delicious.com/ajlopez/javascript+smalltalk
Nos leemos!
Angel “Java” Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez
El próximo fin de semana (19 y 20 de Mayo), se viene la JS Conf en Argentina:
http://jsconf.com.ar/
en la ciudad de Buenos Aires, en el Centro Metropolitano de Diseño. La conferencia es una iniciativa que parte de @rauchg (CTO y cofundandor de LearnBoost, creador de socket.io, su blog en http://www.devthought.com/, sus proyectos en http://www.devthought.com/projects/), como lo anunció en http://www.devthought.com/2012/03/17/jsconf-argentina/. Seguir en Twitter como @jsconfar.
Como pueden ver en el sitio de la conferencia, habrá varios oradores, de Argentina y de otros paises. Para destacar es la llegada de:
Jacob Thornton(Twitter) en @fat
Jacob es un Ingenerio de Twitter y co-autor de algunos proyectos open source interesantes. Como por ejemplo: Bootstrap, Ender, Hogan.js... Estudió literatura en la universidad, lo cual significa que no tiene idea de lo que está haciendo pero es súper crítico de todo.
Isaac Z. Schlueter(Joyent) en @izs
Isaac Z. Schlueter viene trabajando con Javascript hace mucho tiempo. Creó npm (y otros programas en Node) y es el actual líder del proyecto Node.JS. Trabaja para Joyent, y vive en Oakland, California, la capital del mundo del server-side JavaScript y el buen café.
Nathan Rajlich(Learnboost) en @TooTallNate
Nathan es uno de los commiters del core del proyecto Node.js y ha sido un miembro activo de la comunidad por casi dos años. Ha escrito una gran variedad de módulos. Los más destacados son node-gyp, NodObjC, y ansi.js. Él vive en el norte de San Francisco, CA y es uno de los ingenieros en LearnBoost.
y debería nombrar a muchos más, también de Argentina, trabajando en interesantes proyectos, varios de código abierto. Por ejemplo, van a ver que Node.js es uno de esos proyectos. Pero vayan y vean, en el sitio de la conferencia.
Hasta yo voy a estar de orador :-) el domingo, con un temario de los que están acostumbrados en este blog:
Javascript es un lenguaje de programación flexible y ubicuo, que puede ejecutarse del lado del servidor en varias plataformas, y del lado cliente en una plétora de dispositivos. Hay docenas de lenguajes (literalmente) que han sido implementados usando Javascript como lenguaje final. En esta charla, visitaremos algunas formas de implementar intérpretes y máquinas virtuals sobre Javascript, y compiladores que generan código Javascript. Usaremos Logo, Lisp y Smalltalk como lenguajes de ejemplo a implementar, usando Node.js como servidor, y navegadores como clientes.
Ah! La conferencia tiene un costo, para cubrir desayuno, almuerzo, etc. Voy a ver cómo me las arreglo con el efecto Coto :-)
Nos leemos!
Angel “Java” Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez
Se viene otra reunión de este grupo de usuarios. Organizada por @matiasbagini, será el miércoles 23 de Mayo, en sus oficinas de JRapid. Ver detalles y dirección en :
http://www.meetup.com/AWS-User-Group-Buenos-Aires/events/60434612/
Leo ahí:
AWS entregará U$S 20 de crédito para los asistentes al evento.
La reunión de mayo estará enfocada hacia usuarios con poca o nula experiencia en AWS que quieran comenzar a utilizar los servicios. Presentaremos una charla que responderá, entre otras, las siguientes preguntas:
* Qué es AWS?
* Cómo crear una cuenta?
* De qué trata S3 y EC2?
* Cómo es el pricing y cuáles son los diferentes tipos de instancias?
* Conviene usar servidores en USA? Europa? San Pablo?
* Qué es una AMI? cuál conviene usar? Linux o Windows?
* Cómo hosteo mi sitio web en AWS?
* Qué es CloudFront?
* Qué otros servicios ofrece AWS?
La presentación será principalmente práctica para que aquellos que lo deseen puedan irse con su cuenta creada y su primer sitio/aplicación corriendo.
Mis enlaces sobre Amazon Web Services:
http://delicious.com/ajlopez/aws
Ya asistí a la reunión anterior, espero poder asistir a ésta que viene. Tengo pendiente escribir sobre lo que estudié (en la reunión anterior me gané un libro), todavía no usé AWS directamente en un proyecto.
Nos leemos!
Angel “Java” Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez
Se acerca una nueva reunión “meetup” de la gente de Ruby Argentina, en Buenos Aires. @inkel envió este anuncio en la lista RubySur:
Tenemos el agrado de invitarlos a la próxima meetup de Ruby Argentina en Buenos Aires, a realizarse en las oficinas de Wayra Argentina, sita en Costa Rica 5546, Oficina 604.
Para poder ingresar al edificio de Wayra Argentina necesitamos que ingresen su nombre y apellido en el siguiente formulario, y no olviden llevar su cédula o DNI. También pueden anotarse si quieren dar una charla o hacernos sugerencias.
Inscripción: http://goo.gl/68WQw
= Sobre Wayra Argentina http://wayra.org/
Wayra es una iniciativa sin precedentes en el entorno latinoamericano y europeo que pretende conseguir un impacto relevante en la economía de los países en que opera. Si sos emprendedor y tenés un proyecto en el ámbito digital, en
entorno web o soporte móvil, subilo a Wayra que te ayudamos a hacerlo realidad.
Les recordamos que el 13 de mayo es el cierre de inscripción de proyectos para Wayra Argentina 2012. Los interesados deberán completar el formulario de inscripción de proyectos en:
http://wayra.org/es/convocatoria-argentina-2012
El horario es de 19 a 21hs. Atención: la calle es Costa Rica, en el anuncio inicial se había puesto Nicaragua.
La idea del grupo es reunirse una vez por mes. Me gustaría ir a esta “meetup” y hasta preparar una charla, pero no estoy seguro todavía: estoy “en concentración” preparando mi charla para JsConf Argentina (ver anuncio de @rauchg y el sitio), y en el medio de dos proyectos (uno que me lleva a poner a atención a muchos detalles, y otro que me impulsa a pensar mucho ;-). Veo de decidirme este fin de semana.
Aprovecho para comentar que mis charlas en @AltNetHispano sobre lenguajes de programación (en la segunda incluí Ruby) están publicadas en:
http://altnethispano.org/wiki/van-2012-04-14-esos-raros-lenguajes-parte1.ashx
http://altnethispano.org/wiki/van-2012-04-14-esos-raros-lenguajes-parte2.ashx
Mis enlaces sobre Ruby que estuve estudiando o me interesaron:
http://delicious.com/ajlopez/ruby
La gente de la comunidad ya está preparando la segunda RubyConf, hacia finales de este año 2012.
La mención a Wayra, y sus proyectos, es porque ellos buscan propuestas (en varios países), vean:
http://wayra.org/es/tienes-un-proyecto
http://wayra.org/en/do-you-have-project
http://wayra.org/br/tenho-um-projeto
Vean proyectos que seleccionaron en Colombia, México, España, Argentina, Perú, Brasil, Venezuela, Chile y Colombia:
http://wayra.org/es/proyectos-acelerados
http://wayra.org/es/proyectos-seleccionados-argentina
Nos leemos!
Angel “Java” Lopez
http://www.ajlopez.com
http://twitter.com/ahlopez
Anterior post
Veamos ahora otro test, que como los anteriores, nos va a obligar a implementar mejor nuestro software en construcción.
Queremos configurar, sobre la semana básica, cuáles son los días laborables y cuáles son no laborables. En el anterior post, agregué la capacidad de especificar un nuevo día laboral. Ahora, quiero poder especificar que los lunes son no laborables. Este es el test que escribí:
[TestMethod]
public void SetMondayAsANonWorkingDay()
{
WorkingDaysCalendar calendar = new WorkingDaysCalendar();
calendar.AddDayOfWeekAsNonWorkingDay(DayOfWeek.Monday);
DateTime monday = new DateTime(2012, 3, 12);
Assert.AreEqual(monday.DayOfWeek, DayOfWeek.Monday);
Assert.IsFalse(calendar.IsWorkingDay(monday));
}
Primero, no compila. Porque usa el método no existente, AddDayOfWeekAsNonWorkingDay . Lo creo, lanzando una excepción de no implementado, ejecuto el test, y da rojo. Pongamos el mínimo código que hace que esto funcione, con algún refactor de nombre de parámetros.
private DayOfWeek? workingDay;
private DayOfWeek? nonWorkingDay;
public bool IsWorkingDay(DateTime day)
{
if (this.workingDay.HasValue && this.workingDay.Value == day.DayOfWeek)
return true;
if (this.nonWorkingDay.HasValue && this.nonWorkingDay.Value == day.DayOfWeek)
return false;
if (day.DayOfWeek == DayOfWeek.Sunday || day.DayOfWeek == DayOfWeek.Saturday)
return false;
return true;
}
public void AddDayOfWeekAsWorkingDay(DayOfWeek dayOfWeek)
{
this.workingDay = dayOfWeek;
}
public void AddDayOfWeekAsNonWorkingDay(DayOfWeek dayOfWeek)
{
this.nonWorkingDay = dayOfWeek;
}
Ahora el test está en verde. Agregué una nueva variable interna “nullable” nonWorkingDay. Ciertamente que la clase escrita sólo soporta un sólo día laborable configurable y un sólo día no laborable configurable. Pero los tests que escribimos pasan. Voy por “baby steps”, de a “pasos de bebé”.
Pero van viendo la aplicación de TDD: en cada test, hay una nueva especificación de cómo queremos que actúe nuestro software en construcción. Y sólo implementamos lo que necesitamos para pasar el test. Poco a poco, va emergiendo la implementación interna, donde ponemos lo que conocemos como programadores. Pero sin caer en la tentanción de “Ah! acá pongo esto que lo voy a necesitar”. Si el test no lo necesita, nosotros tampoco :-)
Nos leemos!
Angel “Java” Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez
Un nuevo mes comienza, y es tiempo de revisar mis resoluciones del mes pasado, y escribir la lista para este mes. Primero, el resultado de Abril:
- Completar Acquarella (comment, number detection, new styles, language extension..) parcial ver repo
- Trabajar en AjTalk en Javascript/NodeJs (class support, fileouts processing) completo ver repo ver demo en línea
- Trabajar en AjLogo in Javascript/NodeJs (canvas support) completo ver repo ver demo en línea
- Completar el soporte de verbos iniciales en SetTuples pendiente
- Dar una charla sobre Lenguajes de Programación (Javascript/NodeJs, Clojure, Erlang, Python, Ruby, Scala) completo ver video 1, video 2
- Modelo de AjContab en memoria pendiente
Además, hice:
- Dar una charla sobre Clojure completo
- Trabajar en DartSharp completo ver repo
Resoluciones para este nuevo mes de Mayo:
- AjContab modelo en memoria
- Agregar verbos en SetTuples
- Trabajar en Acquarella (extender configuración por lenguaje de programación, soporte de comentarios multi línea…)
- Trabajar en AjLogo en Javascript
- Trabajar en AjTalk en Javascript
- Mejorar la compilación de AjTalk de Smalltalk a Javascript
- Dar una charla sobre implementación de lenguajes de programación en Javascript
- Comenzar con la codificación de AjConsorSite
Muchas cosas, pero gran diversión!
Nos leemos!
Angel “Java” Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez
Anterior Post
Siguiente Post
Ahora veamos de tratar uno de los requerimientos: que los días laborables/no laborables sean configurables, ya sea por feriados puntuales, feriados que se repiten año a año, o porque la propia semana tenga otro reparto de días laborables.
El primero que se me ocurre es contemplar que el sábado sea día laboral. Escribo el test:
[TestMethod]
public void SetSaturdayAsAWorkingDay()
{
WorkingDaysCalendar calendar = new WorkingDaysCalendar();
calendar.AddDayOfWeekAsWorkingDay(DayOfWeek.Saturday);
DateTime saturday = new DateTime(2012, 3, 10);
Assert.AreEqual(saturday.DayOfWeek, DayOfWeek.Saturday);
Assert.IsTrue(calendar.IsWorkingDay(saturday));
}
Al ejecutarlo, da rojo, porque el código que tengo hasta ahora pone a los sábados como días no laborables. Siguiendo la idea de poner el mínimo código necesario para pasar el test, y que sigan dando verde los anteriores, éste es el código que agregué (y luego refactoricé un poco):
private DayOfWeek? workingDay;
public bool IsWorkingDay(DateTime day)
{
if (this.workingDay.HasValue && this.workingDay.Value == day.DayOfWeek)
return true;
if (day.DayOfWeek == DayOfWeek.Sunday || day.DayOfWeek == DayOfWeek.Saturday)
return false;
return true;
}
public void AddDayOfWeekAsWorkingDay(DayOfWeek dayOfWeek)
{
this.workingDay = dayOfWeek;
}
Con esto, el test da en verde. Ejecuto toda la batería de test y sigue dando verde.
Noten que la variable adicional es “nulleable”. Podría haber puesto un arreglo, una lista de días laborables o algo así. PERO NINGUN TEST ME LO PIDIO. Es decir, no hay caso de uso del código que estamos desarrollando que necesite esa flexibilidad. Seguramente en los próximos test tendré que agregarlo. Pero no cruzar el puente ANTES de llegar al puente.
Nos leemos!
Angel “Java” Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez
Anterior Post
Siguiente Post
Sigo con la descripción de los tests que fui escribiendo para este problema. Ahora que ya tengo un test para ver si sábado es día laborable, agregué un test para ver si cada domingo es día laborable:
[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));
}
Inicialmente, el test quedó en rojo. El problema es que el código que llevo escrito solamente reconoce como no laborable a los Sábados. Modifiqué la función que determina eso a:
public bool IsWorkingDay(DateTime day)
{
if (day.DayOfWeek == DayOfWeek.Sunday || day.DayOfWeek == DayOfWeek.Saturday)
return false;
return true;
}
Y el test pasó. Vean que aparecen dos constantes en el código interno. No me preocupa por ahora, porque refleja lo que tengo hasta ahora en los tests. En algún momento, tendré que contemplar (como pedía el problema original) que hay otras semanas típicas: por ejemplo, para un peluquero el sábado puede ser día laborable, y para una panadería el domingo es laborable pero el lunes no.
Llegado a este punto, escribí un test que sale un poco de TDD “estricto”. Es un tests que me dió en verde desde el comienzo. Es el que prueba los días de una semana típica:
[TestMethod]
public void TypicalWeek()
{
WorkingDaysCalendar calendar = new WorkingDaysCalendar();
DateTime monday = new DateTime(2012, 3, 12);
Assert.AreEqual(monday.DayOfWeek, DayOfWeek.Monday);
Assert.IsTrue(calendar.IsWorkingDay(monday));
Assert.IsTrue(calendar.IsWorkingDay(monday.AddDays(1)));
Assert.IsTrue(calendar.IsWorkingDay(monday.AddDays(2)));
Assert.IsTrue(calendar.IsWorkingDay(monday.AddDays(3)));
Assert.IsTrue(calendar.IsWorkingDay(monday.AddDays(4)));
Assert.IsFalse(calendar.IsWorkingDay(monday.AddDays(5)));
Assert.IsFalse(calendar.IsWorkingDay(monday.AddDays(6)));
}
Me gusta tener ese test, para que alguien pueda ver, en un solo lugar, lo que considero para esta API como semana típica. Otros “approach”: no escribir este test, o escribirlo y eliminar los anteriores. Pero yo me “encariño” :-) con los tests, y es raro que los elimine. También dan una idea de la historia, de la evolución de la API. Así que agregué este test de arriba, nacido prístinamente en verde, y dejé los anteriores.
Próximos posts: cómo admitir otro tipo de semanas “típicas”, feriados, etc.
Como siempre, toda esta serie de cambios quedó reflejado en el log del proyecto. Ver https://github.com/ajlopez/TddOnTheRocks
Nos leemos!
Angel “Java” Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez
Gracias a el Java User Group de Argentina:
http://www.jugargentina.org/
el próximo jueves participaré de su Meetup en Buenos Aires:
http://www.jugargentina.org/events/60301992/
Se votaron charlas, y la que había sugerido, ganó la encuesta. Voy a presentar una introducción a Clojure, el lenguaje creado por Rick Hickey que ejecuta sobre la VM de Java, tiene también variantes para .NET CLR y hasta hay Clojurescript sobre Javascript.
Mi idea es presentar las características principales del lenguaje, basado en Lisp, pero con ideas nuevas, como:
- Nuevas estructuras (conjuntos, mapas, secuencias …)
- Manejo de concurrencia (por ejemplo, aparece una implementación de Software Transactional Memory)
- Acceso a la librería de Java
Pensé que tenía 20 o 30 minutos disponibles, como en otras meetups. Pero en las reuniones de Jugar se da una sola charla por vez. Así que voy a aprovechar para dar algo más de Clojure, posiblemente use Leiningen y levante Noir (un framework web).
Creo que ya se llenó el cupo, pero si les interesa Java y su actividad, les recomiendo anotarse como miembros del grupo. Como siempre, terminaré publicando por acá los recursos, ejemplos que haya comentado en la charla. Posiblemente, la gente de Jugar la grabe y la comparta por su web. También, el sábado estaré dando una VAN de Alt.NET Hispano, donde uno de los temas será Clojure (además de Ruby y Python).
Mis enlaces del tema:
http://delicious.com/ajlopez/clojure
Mis posts
http://ajlopez.wordpress.com/category/clojure/
Les recuerdo que hay una lista en español sobre Clojure http://groups.google.com/group/clojure-hispano
Nos leemos!
Angel "Java" Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez
En Marzo dí una charla presencial en el Microsoft User Group de Argentina, en Buenos Aires, ver:
Esos Raros Lenguajes Nuevos: Javascript/Node, Scala, Erlang, Clojure, Ruby, Python
Ahora, el sábado que viene (14 de Abril) y el siguiente sábado (21 de Abril) la gente de ALT.NET Hispano ha organizado dos VAN (reuniones virtuales) para que pueda comentar sobre esos lenguajes, que no son tan raros ni tan nuevos, pero que en general pueden parecerlo dentro de la comunidad .NET:
- Javascript en NodeJs
- Scala
- Erlang
- Clojure
- Python
- Ruby
Este es el anuncio de la primera reunión:
La comunidad ALT.NET Hispano (http://altnethispano.org) realizará una VAN sobre Esos raros lenguajes nuevos NodeJs, Scala, Clojure, Erlang, Python, Ruby Parte 1, con Angel Java Lopez.
Fecha: Sábado 14 de Abril del 2012 a las 18:00 hrs. Hora Internacional (GMT/UTC), con una duración aproximada de 2 horas.
Pueden plantear sus comentarios e inquietudes sobre el tema de la reunión en: https://groups.google.com/d/topic/altnet-hispano/mRQRHvoAvKc/discussion
Para mayor información sobre cómo atender la reunión consulten: http://tinyurl.com/van-hispano
Mi idea es mostrar a qué problemas se orientan estos lenguajes. Por ejemplo, cómo tratan de resolver temas de escalabilidad y computación distribuida en los cuatro primeros (Javascript en NodeJs, Scala, Erlang, Clojure). Y cómo se ha ido formando comunidades, y ecosistemas de paquetes y desarrollo web, especialmente en los dos últimos (Python y Ruby). Mi plan es dar los tres primeros (Javascript/NodeJs, Scala, Erlang) este sábado que viene, y los otros (Clojure, Python, Ruby) en la siguiente sesión.
Este es el primer post de la serie, donde voy a ir escribiendo, comentando sobre recursos y enlaces que fui descubriendo, además de los ya presentados en el post que mencioné al principio.
Nos leemos!
Angel "Java" Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez
Es tiempo de escribir la lista de resoluciones para este mes de Abril de 2012. Primero, un repaso de las de Marzo:
- Templates en AjGenesis en Ruby pendiente
- Soporte de control de flujo en AjLang completo
- Soporte de objetos nativos en AjLisp in Java pendiente
- Primeras estruturas, matching simple, simple REPL en AjErl (erlang en C#) parcial
- Primeras páginas web en AjContab, con un simple ASP.NET MVC, con dominio en memoria pendiente
- Mover AjPython a GitHub, y revisar su implementación completo
- Mover AjSudoku a GitHub, y revisar tests y code coverage completo
- Empezar a refactorizar el algoritmo interno de AjRools para usar RETE pendiente
- Comenzar a procesar formularios en AjComprobantes completo
Hmmm.. demasiado pendiente ;-) Ok, para balancearlos, estuve trabajando en nuevos items:
- Comenzar Acquarella Syntax Highlither completo
- Comenzar AjTalk en Javascript/NodeJs completo
- Comenzar AjLogo en Javascript/NodeJs completo
- Comenzar SetTuples set programming en C# completo
Las resoluciones de este mes:
- Completar Acquarella (detectar comentarios, números, nuevos estilos y lenguajes, extensión por lenguaje …)
- Trabajar en AjTalk en Javascript/NodeJs (soporte de clases, procesamiento de fileouts…)
- Trabajar en AjLogo in Javascript/NodeJs (soporte de canvas)
- Completar el soporte de verbos iniciales en SetTuples
- Dar una charla sobre Lenguajes de Programación (Javascript/NodeJs, Clojure, Erlang, Python, Ruby, Scala)|
- Modelo de AjContab en memoria
Nos leemos!
Angel “Java” Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez
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
More Posts
Next page »