Angel "Java" Lopez

NET, Java, PHP y Desarrollo de Software

This Blog

Syndication

Search

Tags

Community

Email Notifications

Archives

.NET

ASP.NET

Windows Form

VB.NET

C#

Sitios

Blogs

September 2008 - Posts

Modelo textual para generación de código con AjGenesis

Estuve trabajando agregando una "feature" a mi proyecto de generación de código AjGenesis. El sistema maneja un modelo definido por el usuario, que puede ser cargado en memoria desde archivos .xml. AjGenesis puede procesar el modelo, completarlo, invocar a objetos .NET, crear directorios, archivos y aplicar templates para crear código y archivos de texto cualesquiera.

Pero el modelo reside en memoria: la deserialización desde XML es solamente una opción de implementación. Este fin de semana, he agregado el nuevo código en el repositorio de código del proyecto Codeplex: ahora, todo usuario de AjGenesis puede expresar su modelo en texto plano.

El modelo puede, entonces, expresarse en simples archivos de texto. Veamos un ejemplo.

El ejemplo más simple que se me ocurre es el modelo para una aplicación Hello World en AjGenesis. El modelo en XML es:

<Project Company="ajlopez.com"> <Message>Hello, World</Message> </Project>

Ahora, podemos expresar el mismo modelo en un archivo de texto:

Project Company = "ajlopez.com" Message = "Hello, World" End Project

Si necesitamos más mensajes, en XML escribíamos:

<Project> <Messages> <Message>Hello, World One</Message> <Message>Hello, World Two</Message> <Message>Hello, World Three</Message> </Messages> </Project>

Ahora, en texto, podemos escribir:

Project Messages Message = "Hello, World One" Message = "Hello, World Two" Message = "Hello, World Three" End Messages End Project

Se puede cargar el modelo desde el programa de consola, indicando un archivo .txt o .xml:

..\..\..\bin\AjGenesis.Console Model.txt ModuleVb.tpl HelloWorld.vb

..\..\..\bin\AjGenesis.Console Model.xml ModuleVb.tpl HelloWorld.vb

Lo mismo podemos hacer desde tareas de NAnt: cargar un modelo, en un archivo .XML o .txt.

Hay más ejemplos en:

Hello world Examples

Un modelo más realista, donde describimos entidades en un XML:

<?xml version="1.0" encoding="utf-8" ?> <!-- An Entity with Properties --> <Entities> <Entity Name="Customer"> <Description>A Customer</Description> <Properties> <Property Name="Id" Type="Id"/> <Property Name="Name" Type="Text"/> <Property Name="Address" Type="Text"/> </Properties> </Entity> <Entity Name="Supplier"> <Description>A Supplier</Description> <Properties> <Property Name="Id" Type="Id"/> <Property Name="Name" Type="Text"/> <Property Name="Address" Type="Text"/> </Properties> </Entity> </Entities>

ahora puede ser expresado en texto (no es el mismo modelo de arriba, pero similar):

Entities Entity Customer Description = "Customer Entity" Properties Property Id Type="Id" Property Name Type="Text" Property Address Type="Text" End Properties End Entity Entity Supplier Description = "Supplier Entity" Properties Property Id Type="Id" Property Name Type="Text" Property Address Type="Text" End Properties End Entity End Entities

Una vez que el modelo es cargado en memoria, AjGenesis lo procesa como siempre, sin importar su forma original, texto o XML.

Más sobre AjGenesis:

Posts about AjGenesis (English)
Posts sobre AjGenesis (Spanish)

Apenas relacionado, pero interesante:

Problems for Textual Model Notations

Nos leemos!

Angel "Java" Lopez
http://www.ajlopez.com

Posted Mon, Sep 29 2008 5:33 by lopez | 7 comment(s)

AjSharp: un intérprete a la C Sharp, trabajo en progreso

El pasado mes publiqué un proyecto en Google code:

http://code.google.com/p/ajbasic/

Es un intérprete AjBasic, escritbo en VB.NET. El código es la evolución de mi trabajo previo, para mi proyecto de generación de código AjGenesis. En esta nueva versión, el intérprete fue separado en un proyecto aparte, y la gramática de AjBasic y su compilador residen en otro proyecto.

Esa forma de trabajo permite escribir otra gramática y compilador, usando como salida el mismo intérprete núcleo. Así nace AjSharp: pueden bajarlo del mismo repositorio de código de AjBasic.

La solución

Tiene varios proyectos. El proyecto AjInterpreter es exactamente el mismo que en la solución AjBasic. Así, ambas soluciones comparten la misma implementación núcleo de sus primitivas.

El proyecto AjSharp contiene el nuevo compilador, que reconoc código AjSharp, como:

printline "Hello World";

Hay algunos verbos, tomados de AjBasic, como  print y printline. Pero el resto de los verbos son más tipo C#. Mi plan es incluir estas nuevas versiones de AjBasic y AjSharp en el próximo release de AjGeesis, así los que escriban plantillas (templates) para AjGenesis puedan usar cualquiera de los dos lenguajes (está planeado usar un lenguaje .NET directamente, pero esa capacidad quedará para incluir en otra versión futura de AjGenesis).

Como mencionaba en mis anteriores posts:

AjBasic- un intérprete Basic de código abierto
AjBasic- an open source Basic-like interpreter

AjBasic nació para soportar la generación de código en AjGenesis. Lo diseñé para manejar objetos .NET nativos, y también objetos dinámicos. Ahora, eso también está soportado en AjSharp. Un objeto dinámico es un objeto que no tiene una clase, pero que puede soportar nuevas propiedades, definidas en el momento (el ejemplo más cercano que puedo pensar como parecido, son los objetos Javascript).

Podemos escribir código en AjSharp como:

a.FirstName = “Adam“; 

a.LastName = “Doe“;

a.Age = 800;

No hace falta declarar la variable. El objeto se crea y se agrega la propiedad FirstName, en un solo comando (esta creación automática de objetos no está soportada en AjGenesis, todavía).

Podemos preguntar por la existencia de una propiedad:

if (a.LastName)
    printline "a has last name";
else
    printline "a hasn't last name";

Si la variable a no tiene un valor asignado (no existe), o si existe pero no tiene propiedad LastName, la condición de arriba se evalúa a falso. Podemos preguntar por algo como foo.bar.anything y si foo no existe, no aparece ninguna excepción de referencia a null. El resultado completo de esa expresión será, no error, sino null, y en estos lenguajes, null es falso para una condición.

Podemos acceder a objetos .NET, también. Un ejemplo:

di = new System.IO.DirectoryInfo(".");

foreach (fi in di.GetFiles()) {
    printline System.String.Format("File {0}",fi.Name);
}

El intérprete

El núcelo de AjBasic y AjSharp, es el proyecto AjInterpreter, una vista parcial:

Tiene varios nodos definidos, que se usan para formar un árbol de evaluación. Ambos compiladores analizan texto, y lo conviernte a una representación de árbol de nodos AjInterpreter. Hay dos clases principales de esos objetos: Expressions y Commands. Un nodo expression puede ser evaluado, retornando un objeto arbitrario. Un nodo command es ejecutado. Ambas operaciones trabajan sobre un environment, que contiene las variables y sus valores asociados.

Los tests

El compilador, scanner y otros objetos auxiliares, fueron escritos con tests. En la versión publicada, los tests estan en verde:

Consola y GUI

AjSharp.Console es un pequeño programa para probar código AjSharp. Podemos ejecutar archivos .ajs si los colocamos como argumentos, o ingresar comandos por la consola:

AjSharp.GUI is un "feo" programa, que sólo muestra que podemos invocar al intérprete desde un programa WinForm:

Trabajo en progreso

El código actual de AjSharp (y de AjBasic) contiene nuevas características, como el soporte de try/catch/finally en los lenguajes.

Todo este trabajo es trabajo en progreso. Próximos pasos:

- Integrar AjBasic y AjSharp en la próxima versión de AjGenesis

- Soporte para System.Array en ambos intérpretes

- Agregado de un comando for en AjBasic (hay un for each en ambos, y un for tipo C# en AjSharp)

- Operadores de incremento y decremento

- Y mil ideas más... ;-)

Hay dos caminos en el futuro: portar este trabajo a Java, y/o integrar esto con el nuevo soporte de Dynamic Language de .NET. Pero por ahora, integración con AjGenesis es la prioridad. Y, debo confesarlo, este trabajo me divierte mucho.. ;-)

Nos leemos!

Angel "Java" Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez

Posted Fri, Sep 26 2008 12:57 by lopez | 3 comment(s)

Filed under: , , ,

Todo lo que usted quería saber sobre programación y nunca se atrevió a preguntar

En estas últimas semanas, almuerzo y café de por medio, se ha ido gestando una charla que vamos a dar con el bueno de Martín Salías, en noviembre, aquí en Buenos Aires, para el Microsoft User Group de Argentina. En estos días, tengo más contacto laboral con Martín, y eso facilita la organización de nuevas charlas, reuniones. Me temo que nuestros almuerzos han sido regados únicamente por agua mineral o saborizada. Pero han sido comdimentados por discusiones de temas de arquitectura, tecnología, metodologías, y bueyes perdidos.

Ayer terminamos de definir

He aquí el título, subtítulo y temas a tratar:

Vivir programando
Todo lo que usted quería saber sobre programación y nunca se atrevió a preguntar.

Esta jornada cubrirá aspectos generales relativos al oficio del programador, en un espectro amplio que cubre cuestiones filosóficas, de arquitectura, manejo de equipos, proyectos, etc.

Comenzaremos con una breve introducción (de menos de una hora) en la que revisaremos temas generales:


Historia del oficio de programador
Proyecciones y tendencias
Prácticas de Ingeniería
Prácticas de control de proyecto
Estrategias de comunicación


Durante esta introducción, anotaremos temas específicos a profundizar, los que serán priorizados por el público, de manera de profundizar durante el resto de la jornada en los temas más importantes, hasta donde alcance el tiempo.

Algunos de los temas específicos pueden incluir (pero no están limitados a) los siguientes:


Herramientas, Generación de código, Control de Fuentes, Pruebas Unitarias, TDD, Mock Objects, Inyección de Dependencia, Trabajo sobre código Legacy, Análisis de código, Integración contínua, Lenguajes de Programación, Frameworks, Construcción de APIs, Documentación, Capacitación, Soporte, Actualización Profesional, Entrenamiento, Mejora Continua, Recursos (Libros, blogs, revistas), Open Source, etc.

Programar es una actividad fascinante. Y es parte arte, parte ingenieria. En estos últimos años, la actividad de programar se ha ido haciendo más compleja. Ya no es más el trabajo de alguien en solitario haciendo sistemas en Clipper. Ahora múltiples tecnologías, plataformas, requerimientos cada vez más complejos, trabajo en equipo, varias disciplinas a cubrir, temas de comunicación, organización, capacitación, estilos arquitectónicos, prácticas ágiles, patrones, lenguajes nuevos. ¿Cómo programar, en los tiempos de Internet y aplicaciones distribudas, sin morir en el intento?

Tenemos varias fuentes para consultar, desde los libros como Pragmmatic Programmer, bibliografía ágil, Code Complete, varios de Fowler. Pero, por supuesto, vamos a explotar la experiencia de Martín en el manejo de equipos, y el llevado a buen término de proyectos.

Lo bueno de la charla, es que la gente priorizará los temas que le interesan. No es una charla gratuita (Salías está más allá del bien y del mal, pero yo aún sufro del Efecto Coto... ;-) ). Es el martes 11 de noviembre, de 9 a 13hs. Igualmente, algunos de esos temas seran tratados, con tiempo, en posts, con comentarios y enlaces a recursos. En cuanto tenga los datos de inscripción, dejo el enlace en este post.

Posts relacionados con estos temas:

CodeThinked Estrategia para ser un mejor desarrollador
Matriz de Competencias de Programación
Libro Foundation of Programming, listo para bajar
Aprendiendo de Jason Bourne
Levantando catedrales (ahí, un comentario de Martín fue el disparador de esta charla)
Un programador pragmático

¿Quieren algún tema en especial, de los que estan en el temario? ¿Alguno nuevo para sugerir?

(Espero que alguien recuerde la película a la que refiere el título y la imagen)

Nos leemos!

Angel "Java" Lopez
http://www.ajlopez.com/

Posted Tue, Sep 23 2008 13:13 by lopez | 1 comment(s)

CodeThinked | Estrategia para ser un mejor desarrollador

Estoy subscripto al twitter feed de Justin Etheredge. Ayer, publicó el post:

What is your strategy for becoming a better developer-

¡Gran pregunta! Hay tantas respuestas que podrían darse. Puedo escribir algunas de mis favoritas, ahora en español (ayer fue en Anglish, Angel's English en
CodeThinked What is your strategy for becoming a better developer-
):

- Leer: leer revistas, el código de otros programadores, blogs, artículos. No hay excusa, en este mundo tan conectado, para no tomar en cuenta la información, conocimiento y saber de otros. Si uno no tiene tiempo para aprender de otros, estará perdiendo tiempo aprendiendo solo.

- Pensar: Hay que pensar sobre lo que uno lee y aprende. Hay que ejercitar el pensamiento crítico sobre lo que uno conoce, lee y aplica cada día. Un pattern no es una receta escrita en piedra. Un framework X no es la bala de plata que buscamos. Debemos entender cuales son los verdaderos problemas a resolver, en vez de adoptar ciegamente una solución fija. Elevemos nuestro nivel de abstracción, separemos los detalles accidentales del núcleo del problema.

- Escribir: Escriba sus ideas, y lo que aprende. Trate de explicar algo a otro, escribiendo un artículo, post, o dando un código de ejemplo. Para mí, éste es el "deliverable" de cualquier mejora en una habilidad. Como programadores, debemos tener habilidades de comunicación, así podemos pasar nuestras ideas, trabajos, conocimientos e implementaciones a otros. Recuerdo una frase de Richard Feynmann: "si no podemos explicarlo, es que todavía no entendemos el problema". Y si uno escribe sobre lo que aprende, podemos compartirlo con otros. Exponer nuestros descubrimientos de esta forma, es una manera también de recibir "feedback", sobre lo que estamos haciendo. No tema a la crítica: cualquier retroalimentación deberá ser bienvenida.

- Hablar: relacionado con el punto anterior, de una charla sobre el tema que le interesa. Prepare una charla par su grupo local de programación. Ganará visibilidad para Ud. mismo y para su trabajo. Pero el punto principal sigue siendo: cuando Ud. enseña, Ud. aprende.

- Practique: tome trabajos adicionales, haga un "code kata", un ejercicio corto para entrenar sus habilidades. Escriba un mini intérprete, solucione un problema (y para relacionarlo con lo anterior, publique el resultado).

- "Pushing the envelope": salga de su zona de comfort. Aprenda algo nuevo, que no esté entre el conjunto de sus habilidades presentes. Si Ud. es malo en diseño gráfico, vaya e involúcrese en un proyecto que necesite una bonita interfaz de usuario. Si sólo conoce dos lenguajes, o una plataforma, es tiempo de probar otras. Si no se siente cómodo dando una charla, planee dar una: no tiene que ser perfecta, puede darla para su grupo de trabajo, interna. Lo importante es ir mejorando.

Muchas de estas actividades pueden hacerse en grupo. El trabajo de desarrollo de hoy es, en gran parte, trabajo de grupo. Aprenda de otros, de mentoring a otros.

Un post mío relacionado con el tema:

Programmer Competency Matrix
Matriz de Competencias de Programación

Otras respuestas a la pregunta de Justin:

CodeThinked | What is your strategy for becoming a better developer?  "Read.... Stretch...."
Jeremiah Peschka "My strategies tie these all together and are pretty simple, really: Learn and Teach."
Ryan Lanciaux "Read... Share... Set Goals..."
Krishna Kumar "make coding...you must do coding outside of office hours....Choose a problem that you want to solve..."

Nos leemos!

Angel "Java" Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez

Posted Mon, Sep 22 2008 7:38 by lopez | 13 comment(s)

Segunda Semana Sabática del año

Ayer viernes, comenzó mi segunda semana sabática de este año. Generalmente tengo dos semanas sabáticas por año, dedicadas a pensar, leer, escribir, crear y codificar, y a algunas reorganizaciones. Esta "semana" terminará el lunes 29 de septiembre (lo incluye). Prefería viajar, dejando Buenos Aires (Mar del Plata es mi lugar favorito para semana sabática), pero esta vez me quedaré por acá, sin otras obligaciones, excepto codificar para un proyecto en curso. No daré clases, ni charlas, ni habrá reuniones con clientes.

En este post, quiero escribir la lista de lo que quiero hacer técnicamente, en esta semana larga, así me pongo algo de compromiso en cumplir los puntos. La lista es:

- Terminar una primera versión ejecutable de mi intérpreta AjSharp, similar en sintaxis a C#, ahora en desarrollo dentro de mi proyecto AjBasic.

- Escribir el código para soportar un modelo textual en AjGenesis, en lugar de sólo usar archivos XML (que seguirán siendo soportados). Pueden ver algún progreso en el  repositorio de código del proyecto.

- Publicar algunos ejemplos de AjGenesis generando archivos para usar LINQ y soluciones, proyectos de Visual Studio 2008.

- Poner algo de amor en el código del proyecto AjTalk, para soportar la lectura y proceso de definiciones de clases desde archivos tipo .st.

- Escribir dos posts sobre AjGenesis.

- Escribir dos posts sobre F#, para ir adelantando temas para el próximo TechNigh.

- Escribir dos posts que traten sobre CCR (Concurrent and Coordination Runtime) de Microsoft Robotics.

(Los posts serán publicados durante esta semana sabático o en la semana que le sigue)

Posibles "overdelivers" (sin compromiso en firme):

- Integración de AjBasic/AjSharp en AjGenesis.

- Publicar una versión nueva de AjMessage, que soporte el transporte de mensajes via DSS/CCR así como por Windows Communication Foundation.

- Escribir una primera versión de entidades en el "cloud", a la Sql Server Data Services (solamente una librería local, API y tests, aún sin soporte de acceso distribuido).

Es un plan ambicioso, pero divertido. Escribiré sobre los resultados al final de la semana sabática. Tengo otra lista de "commitments" no técnicos (como organizar mis libros en mi nuevo hábitat, acabo de terminar de acomodarlos en nueva biblioteca). También quiero postear en mi blog no técnico sobre temas que me interesan (filosofía, ciencia, matemáticas). Pero esta será una semana sabática más dedicada a lo técnico.

(La foto que uso, la robé, emmm... digo, la tomé del post
Making it Look Easy For those on sabbatical, work is its own reward
)

Algunas notas y resultados de mi anterior semana sabática en este año en:
Semana Sabática
Resultados de la semana sabática

Nos leemos!

Angel "Java" Lopez
http://www.ajlopez.com

Posted Sun, Sep 21 2008 0:01 by lopez | 3 comment(s)

CCR usado en mensajes asincrónicos

Leo en el blog de Arvindra Sehmi que la gente de Tyco Software House implementó un sistema donde usando CCR (Concurrent and Coordination Runtime), la librería que viene dentro de Microsoft Robotics. En su artículo ARCast.TV - Nice Example of CCR Adoption in the Enterprise muestra el video donde la gente de Tyco explica cómo consiguieron procesar gran cantidad de mensajes, basándose en envío asincrónico.


ARCast.TV - Stephen Tarmey of Tyco on adopting Robotics Studio CCR for High Performance Async IO
 

Me gustaría que mostraran algo más gráfico del sistema que armaron, pero igual es interesante escuchar a alquien que usa a Microsoft Robotics aplicado a la empresa.

Ya Arvindra había comentado usos de DSS/CCR más allá de Robotics en

DSS Use Cases in the Enterprise

Todavía algunos de esos usos no están publicados, pero espero que aparezcan más casos de éxito con el tiempo.

El año pasado escribí y publiqué un ejemplo AjMessages, con intercambio de mensajes asincrónicos, usando WCF como comunicación entre nodos de una grilla:

AjMessages- hacia un procesador de mensajes

También el año pasado escribí una versión para usar CCR internamente, y DSS como comunicación entre los nodos, pero no la publiqué. El núcleo del sistema se puede implantar en un host WCF o en un host DSS. Me gustaría en estos días, pulir un poco el código, y publicar el ejemplo, para ver que uno puede usar CCR internamente para encolar mensajes en memoria, y repartirlos en un pool de threads que maneja internamente CCR, mientras al mismo tiempo, repartimos mensajes en otros nodos de la grilla, si los hubiera, sin mayor problema, para conseguir escalabilidad usando más máquinas de forma transparente. Como ejemplo de uso, podría reescribir el Web Crawler o el programa de Fractal, que escribí directamente para DSS/CCR/VPL:

Agentes Distribuidos y Fractales usando DSS/VPL

Agentes Distribuidos usando DSS/VPL

Pero imaginen que pueden repartir una tarea entre varias máquinas, incluso remotas. Imaginen que pueden enviar una tarea a realizar (como recolectar información para un informe de Business Intelligence) a una sucursal, y otra tarea a máquinas de otra sucursal dentro de su empresa. Pueden recibir los resultados como mensajes, usando un patrón del tipo request-response. Podemos codificar "agentes" que se envíen mensajes entre sí, para colaborar en un objetivo.

Creo que el modelo de mensaje asincrónico junto con la implementación de grilla, puede ser explotado de muchas maneras. Mi idea es aprovechar mi semana sabática (que comienza mañana) para codificar algunos proyectos, y uno de ellos es una versión más terminada de AjMessages.

Nos leemos!

Angel "Java" Lopez
http://www.ajlopez.com/

Posted Fri, Sep 19 2008 11:09 by lopez | 4 comment(s)

Noticias y enlaces II

Hoy viene una lista de enlaces, sobre tecnologías, sitios, noticias, de varios temas (siguiendo con el espíritu de la anterior entrega Enlaces y noticias)

Para Noviembre, acompañaré a Martín Salías en una charla para el Microsoft User Group de Argentina, dedicada a visitar y repasar el gran tema de "cómo programar y no morir en el intento". Estamos con Martín meditando los temas, ya tenemos una lista informal, veremos de ir armando la charla de alguna manera ágil, con backlog, iteraciones y demás. Por ahora, ya tenemos el "timebox": hay una fecha para Noviembre. Keep tuned!

El miércoles 10 de septiembre pasado, hubo reunión de Arquitectura y Empanadas, en el MUG de Argentina. Hubo interesantes discusiones sobre SOA, aplicaciones web, el uso de herramientas, y Fabio Maulo estuvo comentando varios detalles sobre el desarrollo de NHibernate y el nuevo sitio de la comunidad http://www.nhforge.org/. Las empanadas estuvieron regadas por gaseosa y latas de cervezas (algunos nos especializamos en estas últimas... :-)). Espero que en breve se repita este tipo de reunión. (Para los que no saben que es una empanada argentina o un repulgue, está el clásico enlace a empanada en Wikipedia).

Ya comenté sobre la reunión del sábado pasado, de Smalltalking, donde asistió Claus Gittinger, creador de Smalltalk/X. Leer Reunión de Smalltalking, con Claus Gittinger y Smalltalk/X.

Ayer fue el cumpleaños del bueno de Roberto Schatz, capi di tutti capi en el tema arquitectos en Microsof. Un saludo desde acá! Vean lo que está haciendo en Puerta 18, en Robótica en Puerta 18.

Apareció un nuevo sitio de comunidad .NET Ideavine- Open source community for .NET. Al parecer, tendran más herramientas de soporte, como un Continuos Integration o similar. Es una creación de James Avery y Nate Kohari.

Si tienen que manejar un equipo distribuido, pueden usar las herramientas de Accelerating Software Development Assembla. Otro lugar, que brinda hosting de SVN es CVSDude- Professional Subversion (SVN) Hosting and CVS Hosting.

Una opinión sobre el avance de .NET sobre Java en .NET outpacing Java-.

Tienen un pdf sobre la implementación con código de la base de .NET en Shared Source CLI 2.0 Internals.

Como saben, soy un entusiasta del uso de modelos para generación de código. Lo importante es el modelo (tema para un próximo post). Entonces, para mí es interesante cómo aparece modelo en el nuevo Oslo de Microsoft. Leer The Origins of Microsoft's Oslo Software Modeling Platform. (se viene un modelo textual en AjGenesis, es decir, en lugar de XML, un lenguaje de texto). Y también me interesa Domain Specific Languages, encontré Embedded typesafe DSLs for Java.

Spring Framework para Java no para de desarrollar nuevas "features". Spring 2.5- New Features in Spring MVC.

Una explicación de por qué JBI (aka Java Business Integration or JSR-208) no despega como Enterprise Service Bus en Enterprise Java Community- The Road to JBI- Paved with Good Intentions.

Veremos que pasa con Rich Internet Applicaciones en Java. Para leer Getting Started With JavaFX Technology.

Un libro que me interesó es Adobe Press - 9780321603944 - Software Pipelines- The Key to Capitalizing on the Multi-core Revo. Podría adaptar mucho de eso a AjMessages y otras formas de aplicaciones distribuidas, no sólo muti-core.

Volviendo a Martín Salías, escribió un post comentando mi anterior El browser de Google- proyecto Chrome , explicando más en detalle lo que se viene con Chrome y la nueva "engine" de Javascript que tiene incorparada. Leer su post Javascript - La programación del futuro (gracias, Martín, por ese guiño en el título recordando a mi libro de Java). Pueden ver el código de la engine V8 en v8 - Google Code. Si quieren seguir de cerca al proyecto, leer su blog oficial Chromium Blog. El código fuente del browser en Chromium - Google Code. El bueno de Scott Hanselman ha comentado sobre la aparición de código de Microsoft en el código de Chrome. Leer The Weekly Source Code 33 - Microsoft Open Source inside Google Chrome.

Encontré por ahí a The Guido van Robot Programming Language lenguaje multiplataforma, para enseñanza de conceptos de programación. Tendría que estudiarlo. Otro con parecida idea es Reeborg's World.

Ejemplos de código Java agrupados por categoría en Java examples (example source code) Organized by topic.

Para los interesados en F#, un punto de inicio con enlaces es F# Programming Fast Guide.

Para los que quieran comenzar un proyecto con NHibernate, y quieren ver cómo se comienza con un ejemplo más de la vida real, leer A Journey with NHibernate - Part 1 y A Journey With NHibernate - Part 2, A Journey With NHibernate (and DDD) - Part 3, A Journey with Domain Driven Design (and NHibernate) - Part 4, A Journey with Domain Driven Design (and NHibernate) - Part 5. Son posts de Ben Scheirman, interesante también Blame NHibernate, Why Not-.

Para los nostálgicos como yo (que recuerdo al Pong de Atari, el próximo nivel en mi adolescencia luego de los flippers... :-)), lean Ten Things Everyone Should Know About Space Invaders. Pueden codificar algo con Space Invaders 101 - An Accelerated Java 2D Tutorial.

Muy interesante el artículo de Fracois Orsini Apache Derby Case Study- Benefits of a Microkernel architecture.

Este es un enlace muy conocido, pero siempre es bueno recordarlo: TIOBE Programming Community Index, donde se listan lenguajes de programación segun su popularidad (ver ahí los detalles de cómo lo miden). No me sorprende el primer lugar de Java, pero no parecen distinguir VB.NET de basic en general, y C# está abajo de Perl. Pero vayan a ver la lista de lenguajes menos conocidos. Creo que es un buen ejercicio, en los tiempos que corren, ejercitarnos en otros lenguajes. Siempre se aprende algo, una nueva perspectiva de los problemas y soluciones.

Soy un entusiasta usuario de Twitter, pueden leerme en http://twitter.com/ajlopez. El sistema es interesante para estudiarlo, como caso de ejemplo (o dis-ejemplo) de escababilidad. Un artículo criticando algo de código de otro microblog en Let the microblogs bloom. Creo igual que el código puede ser mejorado. En el caso de este tipo de aplicaciones, lo importante es la marea de gente que uno tiene, luego la escalabilidad se puede mejorar, cambiando código de base en cualquier momento.

Patrones, estilos arquitectónicos, herramientas, hay muchas de moda. Para comenzar a estudiar Inversion of Control (nombre raro si los hay), pueden visitar primero la introducción y LOS POR QUE de IoC en el post del bueno de Jeremy Miller Before you use an IoC tool, some concepts to know first - Jeremy D. Miller -- The Shade Tree Dev.

Muchos temas de SOA aplicado, en iServiceOriented.com Practical Service Oriented Architecture. Me interesa leer más adelante ahí sobre la implementación de un ESB (Enterprise Service Bus) empezando por Building Our Own ESB - Publish Subscribe Part 1 (7/21/2008)

Matías "El Pibe" Woloski (conocido como gran comedor de cangrejos en China, siempre recordado por su recorrido por la gran muralla enfundado en campera amarilla, lo que le ha valido el apodo en esos lares de "the banana man"... :-)), ha escrito su tesis sobre Software as a Service. Uno de sus posts muestra SaaS Taxonomy Map. Pueden leer sobre el desarrollo de su tesis siguiendo las miguitas de pan que deja en su twitter. Creo que la versión final de la tesis está en Tesis Woloski. Cualquier cosa, vigilan su folder público en Skydrive.

Lean como el bueno de Eugenio Pace descubre una implementación SaaS Eugenio Pace - Software as a Service Architecture Guidance - Northwind Hosting exists, it's bett, y Apprenda - Software as a Service (SaaS) Platform.

En mi anterior Noticias y Enlaces, mencionaba a mi mejor post de este año Posmopolitan. Ahí usé texto generado por computadora. Si alguna vez no estan inspirados, pueden también usar el servicio de Computer poems.

Un poco de humor geek en If People Bought Cars Like They Buy Computers. Con tantas tecnologías y siglas en Web 2.0, un refrescante How to be an instant Web me-2.0 developer.

Me gusta Linux, pero no todo es un lecho de rosas. Creo que este enlace lo encontré en el twitter de Miguel de Icaza o del bueno de Cazzulino: Linux Hater's Blog.

Estoy planificando mi segunda semana sabática del año. Me temo que tendré que seguir atendiendo a algún cliente de programación, pero suspendo mis cursos por 9 días. Comienzo el sábado, veremos qué entregables me comprometo al terminar en esa semana.

Y como siempre al final, un off topic total: el bueno de Sebastian Bassi, del Club de la Razón y Genes Digitales, está vendiendo islas en la Patagonia. Yo no voy a comprar, recien tiré... :-)

Bueno, basta por hoy, espero que encuentren algo útil en todo este rejunte de enlaces... :-)

Nos leemos!

Angel "Java" Lopez
http://www.ajlopez.com/
http://twitter.com/ajlopez
http://friendfeed.com/ajlopez

Posted Thu, Sep 18 2008 13:25 by lopez | 1 comment(s)

Papa fritas, cervezas y una babel de esos raros lenguajes nuevos

Gracias a la gente de Microsoft de Argentina, en especial al bueno de Miguel Saez, tendré el gran gusto de participar de un Tech Night, para el viernes 10 de Octubre, aquí en la sucursal de Buenos Aires, acompañando a Martín Salías y Rodolfo Finocchieti. El tema es los lenguajes de programación, sus paradigmas, en especial, su implementación en .NET. Ya al final de 2005, Martín y yo dimos un TechNight, sobre implementación de distintos lenguajes sobre .NET. En mi opinión, la máquina virtual de .NET (jeje, no van a encontrar un microsoftie que diga "máquina virtual", se les traba la lengua antes, pero es así, es una máquina virtual, como la de Java, ¿vió, señora?), ha sido diseñada con operaciones adicionales a las que tiene Java, y desde el vamos, está preparada para ser usada con otros lenguajes encima, no solamente Visual Basic o C#. Esto ha provocado que la comunidad haya ido montando compiladores, intérpretes sobre .NET. Algunos apuntes sobre esa antigua charla en:

Material de Lenguajes en .NET

Material del Seminario Dialéctica del Software (mostrando un poco la cocina).

Martín ha posteado sobre este nuevo Tech Night:

Technight en proceso

con el abstract:

Programando en Babel: Esos raros lenguajes nuevos

.NET como máquina virtual permite la implementación de múltiples lenguajes. Originalmente el CLR brindó un excelente soporte para lenguajes estáticos y algunos funcionales, proveyendo un sistema de tipos comunes, un garbage collector y varios mecanismos que facilitaban la implementación de lenguajes interpretados y compilados, capaces de reaprovechar la Base Class Library. El nuevo Dynamic Language Runtime (DLR) extiende este poder a los lenguajes dinámicos y otros más experimentales, e incluso está impactando a nivel de diseño las próximas versiones de la plataforma.

En esta sesión haremos una puesta al día sobre las últimas versiones de lenguajes como F#, Boo, ajBasic, IronPython y varios otros. También charlaremos de características generales del campo de diseño de lenguajes y los objetivos de mantener esta variedad. Finalmente, especularemos sobre el impacto que tiene la problemática del desarrollo de lenguajes sobre el futuro de la plataforma .NET.

Me gusta lo de "Programando en Babel", así, que un rapto de originalidad, "copié" la idea de la imagen que puso Martín en su post, y lo puse en este (curiosamente, la imagen original la tomé del artículo técnico Weaving the multilingual Web - Standards and their implementation).

El bueno de Rodolfo (alguien a quien le gustan los lenguajes de programación y la historia de las matemáticas, no puede dejar de ser bueno... :-)... tampoco puede dejar de ser bueno quien escribe un web service dinamyc proxy o un Service Invocation Framework y lo publica), ya estuvo dando con Martín un TechNight sobre DLR (Dynamic Language Runtime) en .NET. Ahora se presentará más trabajo sobre lo que se construyó encima de eso.

Mi participación se centrará en la programación funcional en general, y en F# en particular. Es interesante ver cómo un paradigma algo alejado del "mainstream" igual tiene su lugar, y hasta ha influido en algunas características de .NET, como la aparición de las expresiones lambda.

En el temario quedó también AjBasic, que será un ejemplo de intérprete, con objetos dinámicos y extensibles.

El futuro mostrará qué pasa con el soporte de lenguajes dinámicos en Java, hay que seguir el proyecto de máquina Da Vinci (vean cómo los bytecodes originales de Java tienen que ser extendidos).

Algunos enlaces como aperitivo:

AjBasic- un intérprete Basic de código abierto
AjLisp- un intérprete Lisp en .NET
AjTalk- un intérprete tipo Smalltalk
Recursos de F#
Post sobre F#
http://delicious.com/ajlopez/dlr
http://delicious.com/ajlopez/f%23
http://delicious.com/ajlopez/functionalprogramming
http://delicious.com/ajlopez/lisp
http://delicious.com/ajlopez/haskell
http://delicious.com/ajlopez/erlang
http://delicious.com/ajlopez/ocaml

a-dynamic-language-runtime-dlr.aspx

dlr-trees-part-1.aspx

a-dynamic-language-runtime-dlr.aspx

No sé si conocen cómo termina un TechNight de Microsoft Buenos Aires: con cerveza y papas fritas. Yo creo que voy a ir nada más que por eso... :-).... Hubo un tiempo que había pizza también (recuerdo eso de las reuniones en la segunda oficina de MS en Argentina, en Libertador casi 9 de Julio), pero alguna vez dejamos demasiado sucio el lugar (quedó alguna anchoa en la alfombra) y alguien de la sucursal se enojó.... Bueno, no se puede tener todo en la vida... :-)

Creo que todavía no está publicada la inscripción, pero seguramente aparecerá en:

MSDN Eventos Latam

Nos leemos!

Angel "Java" Lopez
http://www.ajlopez.com/

Posted Wed, Sep 17 2008 12:53 by lopez | 7 comment(s)

Reunión de Smalltalking, con Claus Gittinger y Smalltalk/X

 El sábado pasado, 13 de septiembre, asistí a la reunión de Smalltalking. Esta vez, la reunión fue un café cerca del edificion de la Biblioteca Nacional, aquí en Buenos Aires, Argentina. El grupo es pequeño pero entusiasta, y las discusiones fueron muy interesantes.

El primero en llegar fue Leonardo de Marco, que en estos días está cambiando su vida laborar, para dedicarse de tiempo completo al desarrollo de Smalltalk. Alejandro Reimonde, el "jefe" del grupo, llegó un poco más tarde de las 10hs. Otros miembros que asistieron fueron Esteban Lorenzano, Diego Coronel, Matías Castilla y Juan (sólo Juan, no tengo el apellido...).

Alejandro Reimondo es un referente en el campo del desarrollo en Smalltalk, conocido en el mundo, que ha trabajado desde hace décadas con esta tecnología. Es el fundador del grupo Smalltalking, dedicado a la difusión y discusión de desarrollo de software y más, con Ambientes de Objetes Virtuales. Ya había comentado por este blog sobre su actividad en el desarrollo de multitouch (ver Más sobre multitouch screen).

Esteban Lorenzano enseña arquitectura de proyectos IT, en la Universidad Tecnológica Nacional, de Buenos Aires. La página de la cátedra es:

http://apit.wikidot.com/

Es uno de los fundadores de la nueva empresa Smallworks, dedicada al desarrollo de software usando Smalltalk. Los fundadores son ex Snoop, entre ellos, veo a Evagenlista, al que conocí en algún curso mío hace años.

Diego Coronel tiene una compañía, Informagine (no dió el enlace, supongo que es http://www.informagine.com ), con trabajos para el estado argentina, usando Smalltalk, ahora está trabajando mucho con México. Vive en los dos paises. Curiosamente, Diego y Esteban conocían los mismo lugares de México DF, e intercambiaron impresiones sobre cómo es vivir en esa ciudad, y cómo México albergó y recibió a argentinos, tanto en los años difíciles del siglo pasado, como en este siglo, luego de la "debacle" de 2001.

Matías Castillas es estudiante, vino desde la La Plata (unos 70 km de Buenos Aires). Nos faltó otro platense, Elvio Fernandez, que esta vez no pudo asistir a la reunión. El año pasado, el bueno de Elvio fue anfitrión de otra reunión del grupo, donde hubo buenas charlas, discusiones, una raviolada, y algunas botellas de tinto, que muchos de los integrantes actuales estamos extrañando.

En esta reunión, como en otras, hubo varias discusiones, exposiciones, de distintos temas. Las reuniones no se organizan por temas y tiempo, o apenas, así que muchas veces derivan en temas que no se habían propuesto. Pero siguen siendo interesantes. Entre los temas discutidos estuvieron: la sustentabilidad del desarrollo de código abierto, la situación de la educaciónde objetos y conceptos de arquitectura en Argentina, la escasez de gente, en Smalltalk y otras tecnologías, la rotación de los desarrolladores en las compañías, y el alto salario que se ofrece a desarrolladores juniors, debido a la situación global del desarrollo, y el cambio peso/dólar en Argentina, que hace redituable el trabajo para el exterior.

Con respecto a la rotación, yo podría dar referencias de cómo no tener ese tipo de problema. Pero eso será tema de otros posts. En resumen: hay que dar el ambiente y los desafíos adecuados, para que la gente quiera seguir participando en la misma compañía. También, es importante elegir bien a la gente: es más importante tener la gente adecuada, con una actitud proactiva, y de constante aprendizaje y mejora, en vez de buscar "desarrolladores Java que conozcan Struts" o ese tipo de pedidos.

No se mencionó mucho sobre el tema de metodologías ágiles, que me parecen hoy por hoy, fundamentales para encarar el desarrollo con poca gente. He conocido casos de éxito (y también de fracaso) de excelentes desarrollo con poca gente. Incluso los fracasos enseñan qué tipo de proyectos y de gente necesitamos para avanzar, si tenemos una empresa o un grupo interno de desarrollo.

Alejandro comentó su viaje a Postdam, donde asistió a

Workshop on Self-Sustaining Systems (S3) 2008

The Workshop on Self-sustaining Systems (S3) is a forum for discussion of topics relating to computer systems and languages that are able to bootstrap, implement, modify, and maintain themselves. One property of these systems is that their implementation is based on small but powerful abstractions; examples include (amongst others) Squeak/Smalltalk, COLA, Klein/Self, PyPy/Python, Rubinius/Ruby, and Lisp. Such systems are the engines of their own replacement, giving researchers and developers great power to experiment with, and explore future directions from within, their own small language kernels.

Acá había posteado sobre el tema y el trabajo de Piumarta en:

Self-sustaining Systems, Cola, Pepsi, Coke y Mate

Alejandro comentó que le interesó el trabajo de Richard Gabriel, de IBM (su página personal y bio en Richard Gabriel personal page). Pueden ver el trabajo presentado por Gabriel en:

http://www.tele-task.de/page50_lecture3625.html

Esperamos que sea un tema a tratar en una próxima reunión de Smalltalking (con raviolada y pingüinos de tinto en lo de Elvio... ;-)

Pero la estrela de la reunión, fue Claus Gittinger, fundador de Exept Software AG, y creador de Smalltalk/X. Vino de Alemania, el viernes a la noche, por primera vez visita mi país. Pueden leer su perfil en LinkedIn, encontraran todos los trabajos del bueno de Claus, desde los ochentas. Ha trabajado en varias tecnologías y compañías. En 1995, funda Exept Software, que:

provides solutions, advice and consulting services in the Telecom, Automation, Automobile and other technology oriented software areas.
Products include a state of the art OO-development framework and environment (www.smalltalk-x.de) and frameworks for Test- and Qualitymanagement (www.expecco.de)

Claus se dedica a

Architecture, Project Management, Team Building and Leading, Coaching, Teaching, Testing, Test Management, Prototyping,
Programming Language Implementation, VM design & Implementation, Compiler Construction, IDE Design & Implementation, GUI Framework Design & Implementation, OS-Kernel, OO, Smalltalk, ESUG

También dicta cursos en una universidad de su país. Está visitando Argentina, acompañado de Félix Madrid, un desarrollador argentino que trabaja para Except en Alemania. Como escribía arriba, es la primera visita de Claus a la Argentina, espero que disfrute el viaje y la visita.

Smalltalk/X

Claus fue muy gentil, dedicándonos algunas horas a mostrarnos su trabajo, demostrarnos su producto  Smalltalk/X (noto en Claus el entusiasmo de alguien que ha creado algo y lo ha llevado hasta el nivel de producto, fundando una empresa alredor de ese primer producto). Su empresa se dedica a otros temas (como el testing a partir de un modelo), estas son características de Smalltalk/X (disculpen que no traduzca):

Smalltalk/X, a product from eXept Software AG, is a complete implementation of the programming language, class library and development environment, providing:

  • An object-oriented programming language
  • Graphic development environment with editors, browsers, debuggers, GUI builders, etc.
  • Incremental compilation, byte code interpreter and dynamic (just in time) compiler
  • Static compilation and DLL generation, controlled by make-files
  • Comprehensive class library with ready-to-use modules for applications
  • Open Smalltalk source code

Implementation of the language and class library complies with the draft ANSI standard and the industry standard.

Claus nos mostró la compilación de archivos .st (con código fuente de Smalltalk) a archivos .stc que contiene código C, que puede compilarse en varias plataformas (en Windows, podemos compilar el sistema completo usando Borland C, o con Microsoft Visual C++). De esta manera, podemos producir programas nativos ejecutables desde nuestro proyecto Smalltalk. Más características de la documentación:

ST/X Smalltalk is a complete implementation of the Smalltalk language. Smalltalk/X is not based on the original ST-80 virtual machine implementation and has been written from scratch. However, the API, class libraries and language semantic is highly compatible to ST-80 based smalltalks, such as VisualWorks, Squeak and others.

Smalltalk/X consists of both an integrated environment for program development AND a standalone smalltalk compiler(1), which generates true machine code, shared code libraries and binary executables without a need for a so called "image". However, traditional image-based development is also supported and typically used for program development.

The programming environment includes editors, browsers, compiler and debugger and a large library of ready to use building blocks for application writers.
The standalone compiler generates true machine code from smalltalk source files - and can be used in a batch environment for production/delivery.

Features

  • Language syntax and semantic compatible to the industry standard, including arbitrary precision arithmetic and automatic number conversion, exception handling, automatic memory management, threads, contexts, blocks (block closures), metaprogramming and much more.
  • Additional (mostly backward compatible) extensions to the smalltalk language include: private classes, multiple namespaces, method privacy and end of line comments.
  • A comprehensive threadsafe library of basic classes, including collection classes, numeric classes, streams, lightweight processes, exception handling and metaclass hierachy.
  • Many user interface widget classes usable as building blocks for graphical applications. These are fully (non-polling) event driven, multithreaded and support multiple displays, parametrized view styles, wide characters (unicode) and national languages.
  • Integrated programming environment including browsers with sophisticated refactoring and code generation support, GUI- and Menu builders, monitors and symbolic debugger for efficient program development.
  • The additional Scripting Engine allows for command-line execution of smalltalk scripts. These script files can be generated by any other editor, or alternatively by saving code from the IDE (file-out from the browser).
  • Debug once - run everywhere !
    complete Source- and Byte-Code compatibility between Unix and Windows versions. Write your application once, run it without change on Win-NT, Linux, Alpha-OSF, Sun-solaris, HPUX, AIX, Silicon-Graphics IRIX(4).
  • Many demo and 'how-to' example programs
  • Online HTML documentation and class documentation generator, visualized by the ST/X HTML document viewer.
    Well documented classes and methods.
  • Very liberal licensing conditions

Implementation hilights

  • Incremental compilation to internal bytecodes for short turn around cycles during development.
    Binary files containing bytecode are portable across different machine architectures.
  • Dynamic (just-in-time) compilation from internal bytecodes to machine code (2).
    Except for the faster execution, this is transparent to the program or user.
  • Batch compilation to real machine code for high performance production code, enabling the creation of binary object modules, class libraries or even shared class libraries.
    Since more optimizations and code analysis are performed by this (offline) compiler, the resulting code executes faster - even when compared to dynamic compiled machine code.

    Although static compiled machine code leads to bigger executables, the main advantage (beside faster execution) is the deterministic runtime behavior, which cannot always be guaranteed, if bytecodes are compiled dynamically at execution time.
    In addition, big applications benefit from static compilation by the sharability of this compiled code among multiple applications, if shared libraries and/or shared text segments are supported by the operating system.

    Applications can (and do) use a mix of precompiled machine code classes and interpreted bytecode classes - this is transparent to the program or programmer.

    If supported by the operating system (3), machine compiled modules can be dynamically added to and removed from the running system.

  • Easy creation of standalone executables and applications without graphical user interfaces. This includes self-extracting installation code for windows platforms (null-soft self installing executables).
  • Easy binding to C-language by allowing inline c code (even inline assembler by using asm statements) or via the ffi-callout mechanism to dynamically loaded shared libraries (dll's).
  • Sophisticated window interface combining event and process driven techniques.
    ST/X supports multiple display devices - you can work with others in the same object environment, or write applications which serve multiple screens.
    Your application can even run on a display-less host, serving multiple xTerminals or client applications via TCP connections.
  • Additional protocol provided in the process, semaphore and processor classes, for better thread synchronization. ST/X's process handling includes additional mechanisms for recovery (semaphore cleanup) in exceptional situations, which is required in technical applications. The ST/X's process scheduler supports timeSlicing and dynamic thread priorities. This allows for better response behavior in multiwindow applications and allows progress of background processes even in case of busy foreground processing.
  • Modern generational garbage collector, with dynamic adjustable newSpace, adaptive tenuring, both incremental and non-incremental collectors for the oldSpace, both copying and non-copying compressors for the oldSpace.
  • Object finalization via the WeakArray mechanism; in addition, a number of other collection classes are available with weak references (WeakSet, WeakDictionary etc.)
  • Both ANSI compliant class based exceptions and (VW-) backward compatible Signal-based exceptions are supported.
    In addition, process specific and global default exception handlers are avaliable, to allow for non scoped, global exception handling.
  • The byteCode interpreter and just-in-time compilers support multiple bytecode sets, for total integration of different languages into a single unified system.
    In the current release, this feature is used to support execution of compiled Java code.

Claus también mostró que se puede compilar al vuelo, en el entorno de desarrollo. Uno puede escribir un método, y se traduce a los bytecodes clásicos de una máquina virtual Smalltalk. Pero durante su ejecución, esos bytecodes se compilan a código nativo.

Es aquí donde atiborré de preguntas al paciente de Claus. Su implementación se desvía de una implementación clásica de Smalltalk, no es una implementación como otras. Esto para mí es interesante, así que pregunté en detalle algunos temas.

Smalltalk/X no usa una tabla de objetos, con lo cual cada objeto apunta directamente a otros objetos. Esto facilita algunas cosas, pero complica otras, como el ajuste de los "punteros" durante el proceso del garbage collector (garbage collector), la implementación de become: es prácticamente difícil (no ví todavía si consigue implementarlo Smalltalk/X), y el garbage collector tiene que tomar control en algún momento, para ajustar todos los objetos. El garbage collector es un mark and sweep, con copy de objetos. No usa generaciones de objetos, aunque mantiene un age en la cabecera de cada objeto. (Corrección, el bueno de Claus me comenta en Smalltalking meeting, with Claus Gittinger and Smalltalk/X que lo de mark and sweep, es sólo una de cuatro estrategias, y se aplica solamente a los objetos viejos).

Podemos bajar los binarios del sistema, o podemos bajar el CVS de la compañía (esten preparados para un download con tiempo: son más de 20000 files, >180 megas, a mí me tomó algunas horas de bajada).

Como notan, estuve muy interesado en los detalles de implementación de la VM. Me interesó desde siempre la construcción de ese tipo de sistemas, pueden leer algo de lo que estoy haciendo con mi trabajo en progreso sobre el AjTalk en AjTalk- un intérprete tipo Smalltalk). Algo interesante: como genera código C, en los archivos .st se pueden incluir fragmentos de ese lenguaje, además de llamadas a las clásicas primitivas. Por ejemplo, en el archivo Object.st, que define la conducta de Object, encuentro:

basicAt:index "return the indexed instance variable with index, anInteger..." ... %{ /* NOCONTEXT */ REGISTER int nbytes, indx; OBJ myClass; REGISTER char *pFirst; REGISTER int n; ... if (__isSmallInteger(index)) { myClass = __qClass(self); indx = __intVal(index) - 1; n /* nInstVars */ = __intVal(__ClassInstPtr(myClass)->c_ninstvars); n /* nInstBytes */ = OHDR_SIZE + __OBJS2BYTES__(n /* nInstVars */); nbytes = __qSize(self) - n /* nInstBytes */; pFirst = (char *)(__InstPtr(self)) + n /* nInstBytes */; ... }%

Despues de pasearlo por temas de implementación, Claus nos siguió mostrando temas del entorno gráfico de desarrollo, con los clásicos workspaces, browsers, implementados directamente en Smalltalk. El producto de Claus maneja directamente distintas implementaciones GUI, sean Windows, Unix, Linux, y demás. Desde un entorno GUI que trae el producto, podemos definir controles, formularios, asociarlos a métodos. También hay soporte de MVC (Model View Controller), donde rápidamente el valor de un control puede modificar el modelo, y su cambio se refleja en otros controles, si queremos. Claus igual comentó que los controles los tienen que diseñar ellos, cuando en el mercado aparece un nuevo tipo de control, por ejemplo, una grilla, ellos no la aprovecha, sino que la implementan en su base de código. Eso permite que ese nuevo control, automáticamente esté disponible en todas las plataformas donde ejecuta Smalltalk/X. Pero imagino que se complica estar al día en el desarrollo de widgets gráficos.

También mostró un servidor HTTP. Con el servidor HTTP funcionando, uno puede definir clases que atiendan pedidos por URL. Implementamos un método que recibe un objeto request, de ese objeto obtenemos un response, y con éste, comenzamos a emitir el contenido del documento, generalmente un HTML. No llegué a ver el soporte que tiene de controles dentro de una página. No llegué a probar eso en mi máquina todavía, y no vi "screenshots" en el sitio de Exept.

Independientemente de Smalltalk/X como producto, si estan interesados en Smalltalk, pueden visitar la página de enlaces y la de documentación (con libros sobre Smalltalk, para bajarse libremente).

Gracias desde acá a Claus Gittinger, por dedicarnos tiempo y compartir su conocimiento con todos. Fue una interesante reunión. Claus es alguien que cumple con el mindset Don't be a canuto.

No estuve hasta el final (tuve que ir a dar mi charla de Microsoft Robotics, en Puerta 18, más datos en Robótica en Puerta 18). Una de las últimas preguntas mías a Claus, fue si usan metodologías ágiles en su empresa. Contestó que sí, pero hubiera sido interesante conversar más en detalle. (Curiosamente, uno de mis contactos en LinkedIn que me unen a Claus, es el bueno de Tobias Mayer, que fue mi entrenador en Scrum).

Espero que tengamos por lo menos una reunión más este año de Smalltalking. Tengo minutas de otras reuniones anteriores, tengo que pasarlas en limpio, ya aparecerán por aquí en formato post. Ya conocen el otro mindset: Lo que no está escrito, no existe. ;-)

Nota adicional: Alejandro, en ánimo turístico, nos comentó sobre el monte del infierno, en las afueras de Berlin. Pueden ver la ciudad desde ese "monte" artificial, armado con los escombros que quedaron al final de la segunda guerra mundial, desde

http://www.panoramio.com/photo/7847858

También comentó sobre Praga, una ciudad que no fue afectada por bombardeos, y no tuvo que ser reconstruida:

http://www.panoramio.com/user/592876/tags/Praga

Nos leemos!

Angel "Java" Lopez
http://www.ajlopez.com

Posted Tue, Sep 16 2008 11:58 by lopez | with no comments

Filed under:

Robótica en Puerta 18

Ayer sábado, di una charla sobre Microsoft Robotics (pueden ver la presentación y enlaces en Recursos de Microsoft Robotics Developer Studio), en Puerta 18. Fui invitado por el bueno de Roberto Schatz, que está dictando un curso de robótica.

Puerta 18 se encuentra en el barrio del Abasto, en Buenos Aires. Ahí hacen actividades de diseño gráfico, dibujo, grabación de sonido, diseño de arquitectura, y robótica, entre otras, con adolescentes, que asisten de forma gratuita. El emprendimiento está soportado por la fundación IRSA, y es afiliado del Computer ClubHouse.

Dí una charla de una hora, mostrando las capacidades del MRDS. La gente de Puerta 18 ya dió un curso de robótica, de dos meses, donde trabajaron con un Lego NXT. El resultado de ese curso se puede ver en:

En curso anterior, los chicos formaron dos equipos, donde el desafío fue programar al robot Lego para que pudiera escapar de un laberinto. El resultado está en el video.

Ayer comenzó una nueva instancia del curso. Roberto Schatz dió una clase magistral, mostrando cómo programar un Lego NXT, que reacciona por un golpe en su "bumper", y comienza avanza. Luego mostró cómo conseguir un comportamiento "animal", tipo cucaracha: hacer que el Lego NXT ante un nivel de luz comienza a avanzar, y ante otro nivel menor, para el motor. Todo desde el ambiente de programación de la propia empresa Lego.

Los asistentes, creo que de 10 a 18 años, se dedicaron a armar un segundo Lego NXT que ahora tienen en Puerta 18.

En las próximas clases del curso, se planteará:

- Rehacer el desaf[io del laberinto del curso pasado
- Plantear un robot en Mindstorm que reaccione ante otros (tipo juego de la mancha), que escape, que haga pases con una pelota.
- Interacción entre robots
- Armado de competencia de Sumo en robtos
- Programación con robot virtual

En noviembre viene el cumpleaños de Puerta 18. El curso de robótica espera exhibir entonces los trabajos realizados.

Pueden encontrar los datos de contacto de Puerta 18 en la lista de afiliados del Computer ClubHouse:

Puerta 18 Computer ClubHouse

Pueden ver la cantidad de paises donde está instalada esta institución en:

Computer Clubhouse locations

Son parte del Computer Museum, y tiene el soporte también del MIT Media Lab.

Gracias desde acá, a Roberto, y a la gente de Puerta 18, por haberme invitado. Fue una interesante experiencia para mí, ante un nuevo tipo de público, que veo que tiene muchas ganas de hacer cosas. Felicitaciones por lo que estan haciendo.

Nos leemos!

Angel "Java" Lopez
http://www.ajlopez.com/

Posted Sun, Sep 14 2008 13:05 by lopez | with no comments

Arquitectura de capas en Domain-Driven Design

Esta vez, exploremos los conceptos de arquitectura en capas, tal como lo propuso Eric Evans en su libro clásico Domain-Driven Design, Tackling Complexity in the Heart of Software. En el capítulo cuatro del libro, Evans presenta este diagrama:

 

Evans Escribe:

En una aplicación de carga y envío de mercadería, para simplemente listar y seleccionar el destino de la carga de una lista de ciudades, debe haber código que (1) dibuje un control en la pantalla, (2) consulte una base de datos para obtener las posibles ciudades, (3) interprete el ingreso de usuario y lo valide, (4) asocie la ciudad seleccionada con la carga, y (5) confirme el cambio en la base de datos. Todo este código es parte del mismo programa, pero sólo una pequeña parte está relacionado con el negocio de envío de cargas.

El propone que el modelo de dominio resida en una capa, la Capa de Dominio. De esta forma, el modelo de dominio es protejido de los detalles técnicos, como la implementación de la persistencia, y los detalles de presentación. Me gusta decir que el dominio es un organismo, qe recibe estímulos, acciones desde el exterior,y reacciona a esos comandos. El dominio debería ejecutarse sin conocimiento detallado del resto de la aplicación. Serialización entre capas físicas, detalles de presentación, y acceso a base de datos, deben estar claramente separados de la implementación del dominio.

Las capas puede ser descriptas como:

UI (User Interface): la más fácil de entender, esta capa es la responsable de mostra información al usuario, y aceptar nuevos datos. Puede ser implementada para web, escritorio gráfico, o cualquier otra tecnología de presentación, presente o futura. Por ejemplo, podría ser una aplicación de voz, que interactúa con el usuario usando un teléfono. La prueba ácida para nuestro diseño es que un cambio radical en la interfaz de usuario debería tener mínimo (o por lo menos, controlado) impacto en el resto del sistema.

Application Layer: está a cargo de coordinar las acciones a ser realizadas en el dominio. No tiene reglas de negocio o conocimiento del dominio. No hay estado del negocio en esta capa. Delega todas las acciones del negocio al propio dominio. Podría coordinar varias acciones (posiblemente, en varios dominios). Preara la infraestructura para que esté lista a trabajar con el dominio en una acción específica (por ejemplo, preparando la transacción que vaya a usar).

Domain Layer: En esta capa reside el corazón del software, según Evans. Las reglas y lógica de negocio residen en esta capa. Estado de entidades de negocio y su conducta es definida y usada aquí. Comunicación con otros sistemas, detalles de persistencia, son delegados en la capa de infraestructura. Evans discute los patrones que él usa en esta capa, como Entities, Value Objects, Services, Repositories y Factories. Exploraremos esos patrones y sus implementaciones en futuros posts.

Infrastructure Layer: Dios y el diablo estan en los detalles, dice el dicho, y también en la capa de infraestructura. La principal responsabilidad de esta capa es la persistencia del estado de negocio, muy frecuentemente, usando una base de datos relacional.

Mi idea es tomar un ejemplo (posiblemente un dominio como uno del libro de Jimmy Nilsson), y desarrollarlo usando estas ideas, mostrando código concreto en Java y en .NET. En algún punto, discutiré sobre generación de código desde un modelo abstracto, pero no será el foco de esta serie de posts.

Fuentes consultadas:

Domain-Driven Design, Tackling Complexity in the Heart of Software, de Eric Evans.
Applying Domain-Driven Design and Patterns: With Examples in C# and .NET, de Jimmy Nilsson
.NET Domain-Driven Design with C#, Problem, Design, Solution, de Tim McCarthy. (Hay una sección en el blog de Tim dedicado a este libro).

Pueden bajar libremente

Domain-Driven Design Quickly

desde InfoQ.

Nos leemos!

Angel "Java" Lopez
http://www.ajlopez.com

Posted Sat, Sep 13 2008 11:29 by lopez | 2 comment(s)

Congreso de Inteligencia Computacional Aplicada

Hay un activo grupo de Inteligencia Artificial en la Universidad de Palermo, aquí en Buenos Aires, Argentina. Estan organizando un congreso internacional de Inteligencia Computacional Aplicada para el próximo año, 2009:

http://www.palermo.edu/ingenieria/cica.html

Congreso de Inteligencia Computacional Aplicada (CICA)



El 23 y 24 de julio de 2009 se llevará a cabo el Congreso de Inteligencia Computacional Aplicada (CICA), en la ciudad de Buenos Aires.
El Congreso, tiene por finalidad analizar el estado del arte de esta disciplina, desde un punto de vista de sus aplicaciones prácticas, en el país y en el mundo; generar un  debate entre pares nacionales e internacionales sobre las problemáticas centrales de esta materia y promover la integración de profesionales, investigadores y empresas e industrias, en un marco en el que prevalecerán las innovaciones tecnológicas encaminadas a buscar el beneficio de la comunidad.
Contacto:
Tel: 5199-4520
E-mail: cica@palermo.edu

Yo ya tengo mis años, y lo que se llamaba Inteligencia Artificial, ha ido abriéndose en varias ramas. He asistido al auge y caida de los sistemas expertos en los 70 y 80, al relegamiento de los perceptrones de Rossenblat, ante el "ataque" del libro de Minsky y Papert, el resurgimiento y auge de las redes neuronales, lógica difusa y algoritmos genéticos, y a la vida artificial. Ahora, se llama Inteligencia Computacional a un grupo de disciplinas que se separan de la "vieja inteligencia artificial" (GOFAI "Good Old-Fashioned Artificial Intelligence").

Según la IEEE (según el artículo de la Wikipedia), las ramas de la inteligencia computacional son

  • Neural networks
  • Fuzzy systems
  • Evolutionary computation, incluyendo: genetic algorithms y genetic programming
  • Swarm intelligence, incluyendo particle swarm optimization
  • Estoy leyendo el libro Computational Intelligence: Concepts to Implementations, transcribo el primer párrafo del prefacio:

    Several computational analytic tools have matured in the last 10 to 15 years that facilitate solving problems that were previously difficult or impossible to solve. These new analytical tools, known collectevily as computational intelligence tools, include artificial neural networks, fuzzy systems, and evolutionary computation. They have recently been combined among themselves as well as with more traditional approaches, such as statistical analysis, to solve extremely challenging problems...

    Volviendo al congreso, en la página leo el "call for papers":

    http://www.palermo.edu/ingenieria/Congreso_inteligencia_computacional/papers.html

    Vean los comités:

    http://www.palermo.edu/ingenieria/Congreso_inteligencia_computacional/comite_organizador.html

    (todos nenes de pecho... ;-)

    Y los keynote speakers:

    http://www.palermo.edu/ingenieria/Congreso_inteligencia_computacional/invitados_especiales.html

    Robert C. Berwick Ph.D.
      Professor of Computational Linguistics
      Department of Electrical Engineering and Computer Science
      Massachusetts Institute of Technology – USA
    • Stan Franklin Ph.D.
      W. Harry Feinstone Interdisciplinary Research Professor
      Cognitive Computing Research Group
      Department of Computer Science
      Institute for Intelligent Systems
      The University of Memphis - USA
    • Piero Bonissone Ph.D.
      Industrial Artificial Intelligence Lab
      Computing and Decision Sciences Technology area
      General Electric Global Research – USA

    Estoy muy interesado en el trabajo de Stan Franklin, y sus ideas y trabajos sobre inteligencia con un cuerpo, agentes autónomos que interaccionan con el ambiente, es un tema que tiene desde aplicaciones prácticas hasta aristas de filosofía, como el problema mente-cuerpo, y el problema de a conciencia. Pueden tomar un "paper" de hace diez años, para comenzar a entender a Franklin:

    Autonomous Agents as Embodied AI

    Artículos más recientes del bueno de Franklin en:

    http://ccrg.cs.memphis.edu/papers.html

    Robert Berwick, del MIT, es un referente en el tema de linguística computacional. Yo creo, que desde Chomsky, se ha puesto demasiado énfasis en el tema lenguaje, que debería ser estudiado como un epifenómeno de algo más nuclear, más profundo, de la mente, como es el tema de la representación, la formación de conceptos, y otras operaciones mentales.

    No conocía a Piero Bonissone, que está, al parecer, interesado en todo lo que sea fuzzy systems. Ahora está en General Electric, desarrollando algoritmos para aplicar en salud, logística y aplicaciones financieras.

    Más sobre Inteligencia Artificial en general en:

    http://delicious.com/ajlopez/artificialintelligence

    Gracias a Pablo Cababie, por avisarme de este evento, y por el esfuerzo que él y su grupo de la Universidad de Palermo estan poniendo para organizar este congreso, excelente iniciativa, que pone visible a la Argentina. Si bien el mundo es plano, es bueno tener visitantes del exterior, mostrar lo que se está haciendo en mi pais, y tener contacto directo con gente interesada en estos temas.

    Nos leemos!

    Angel "Java" Lopez
    http://www.ajlopez.com/

    Posted Thu, Sep 11 2008 13:18 by lopez | 3 comment(s)

    Recursos de Microsoft Robotics Developer Studio

    En estos días, estuve dando varias charlas sobre Microsoft Robotics Developer Studio (MRDS), quisiera escribir acá sobre lo que presento en esas charlas, y enlaces a recursos del tema.

    En primer lugar, pueden ver todo sobre el producto de Microsoft desde:

    Microsoft Robotics

    Ahí encontraran para bajarse el Microsoft Robotics Developer Studo 2008 (actualmente CTP July), y descargas adicionales.

    La presentación original de la charla es la que dio Arvindra Sehmi en el Regional Architect Forum de México:

    Mexico Regional Architect Forum 2008

    En el blog de Arvindra, pueden encontrar información adicional sobre el uso de MRDS en la industria, más allá de robótica:

    DSS Use Cases in the Enterprise

    Mi presentación en español, la pueden bajar de my Skydrive:

    Presentación de Microsoft Robotics (14 megas)

    En la charla muestro algunas de las ideas y ejemplos de diseño, implementación y tecnologías usadas en MRDS:

    Decentralized Software Services

    Basado en principios de diseño de REST (Representational State Transfer), es la base que tiene MRDS para operar en forma distribuida de forma eficiente. Usa estándares de la industria, como HTTP para el envío y recepción de mensajes, XML y SOAP para el protocolo de transporte. Todo MRDS se basa en tener un host (servidor) de DSS (el DssHost) que levanta servicios. Los servicios son los elementos que nosotros programamos. Dentro del software viene ya servicios provistos, para manejar e interactuar con robots simulados y reales, y con cámaras, sensores, motores, y otros elementos, como ventanas y joysticks. Los servicios se comunican entre sí usando DSS. Podemos manejar uno o varios robots, desde una o varias máquinas. O podemos, como muestra la imagen, ver el estado de un servicio, como una cámara de video, apuntando en nuestro browser a la dirección donde se encuentra el servicio (puede ser nuestra máquina u otra máquina).

    Concurrent and Coordination Runtime

    Otra de las novedades del sistema, es una nueva librería que simplifica y potencia el uso de mensajes para comunicar distintas partes de nuestra aplicación. Podemos enviar un mensaje a un Port, y dentro de ese Port podemos programar cómo atendemos a ese mensaje. Toda la atención de los mensajes se maneja de una forma eficiente, usando múltiples hilos de ejecución, y un manejo interno nuevo de lo que se llama un pool de threads. Es interesante explorar las capacidades de CCR, que se puede usar como librería desde fuera de MSRS. Podemos armar sistemas compuestos de componentes que se envíen mensajes asincrónicos entre sí. Los componentes pueden residir todos en el mismo programa y máquina, o podemos usar DSS para que los mensajes viajen entre distintos servidores.

    Visual Programming Language

    Teniendo un servidor de servicios DSS, los servicios se pueden programar en el Visual Studio, o pueden coordinarse los servicios a usar, detallando los mensajes y su proceso, usando el Visual Programming Language, una forma de conectar esos servicios de forma visual. Usando un diseñador interactivo, arrastrando y soltando servicios, y conectando sus mensajes de salida y entrada, podemos modelar un programa, un nuevo servicio, que por ejemplo conecte nuestro joystick o ventana de control, con robots, dispositivos u otros servicios. Uno de los ejemplos que muestro, es cómo interactuar con un servicio de Text to Speech (texto a voz).

     

    Simulation Environment

    No necesitamos tener un robot físico para interactuar. MRDS nos brinda un entorno de simulación, para manejar entidades (poliedros, esferas, entidades complejas como mesas, paredes, robots).

    El entorno de simulación es otro servicio más, que se levanta dentro de un host de DSS. Nuestros servicios pueden enviarle mensajes, como "crear suelo", "crear cielo", "crear sol", "agregar entidad esfera". Las entidades tienen características, que incluyen densidad, peso, cómo las afecta la gravedad.

    Este entorno de simulación está basado en tres tecnologías, que se instalan (si no las tiene ya instaladas) con el MRDS: el DirectX 9, el Microsoft XNA (para el render de 3 dimensiones), y el AGEIA PhysX que simula la física del entorno. Estas tecnologías pueden ejecutarse basadas en software, o pueden aprovechar hardware especial que tenga instalada la máquina: tarjetas de video con soporte de 3D, o plaquetas de simulación física.

    Como todo servicio, el entorno de simulación puede ejecutar en una máquina, y el resto de los servicios estar repartido en otros servidores de la red. Por ejemplo, pueden colocar varios robots en un entorno de simulación, y cada uno manejarlo desde una máquina dedicada.

    Robochamps

    Es un sitio donde aparece desafíos a resolver con MRDS, donde programadores de todo el mundo pueden participar resolviendo un problema. El primer concurso fue ganado por Dave Sprague, entusiasta de robótica de los EE.UU., y Jackson Matsuura, profesor de Brasil. En el Desafío Amazed compitieron participantes de 77 países. Ahora se abre el desafío Sumo donde dos robots, en un ring, tiene que maniobrar para echar al otro fuera de la arena.

    Encontraran videos explacativos (en inglés) sobre las tecnologías que se usan en MRDS, así como ejemplos para bajarse.

    Enlaces

    En la charla menciono algunas implementaciones de gente de la comunidad, involucrada en robótica, y que usa MRDS.

    Como el sistema puede ejecutarse en un Windows Compact Edition, se puede instalar en un dispositivo de Windows Mobile. Eso es lo que Brian Cross, con su:

    http://www.wimobot.com/

    WiMoBot es el Windows Mobile Robot. Usa un Windows Mobile 5.0 SmartPhone como el cerebro central de control. Cross lo ha extendido para poder ser manejado remotamente desde una PC usando MRDS. Hay una versión montada sobre el lego NXT en:

    http://www.wimobot.com/AssemblyNxt.aspx

    como el sistema operativo

    Raúl Arrabales Moreno está trabajando desde hace tiempo, en Inteligencia Artificial y robótica. Pueden visitar su sitio de

    http://www.conscious-robots.com/

    Está trabajando con MRDS, del que destaca sus características de manejo de concurrencia, coordinación, mensajería asincrónica. Está usando MRDS son el robot Pioneer 3DX, uno de los robots reales y simulados soportados por el sistema. Encontraran ahí foros sobre robótica

    http://www.conscious-robots.com/en/researchers-and-associations/discussion-forums/www.conscious-robots.com-f.html

    como

  • PSYCHE-B Discussion Forum
  • PSYCHE-D Discussion Forum (Theoretical emphasis)
  • Language Mind and Consciousness
  • Conscious-Robots.com Forum for MSRS (English)
  • Conscious-Robots.com Forum for MSRS (Spanish) (muy recomendable, con abundante información, preguntas y respuestas de los participantes)
  • MSRS Official Forums
  • Robocup MSRS Challenge Maillist
  • Posts y ejemplos

    Post que escribo sobre Robótica en general, a partir de:

    Posts sobre Robótica

    Algunos de los ejemplos que muestro en la charla:

    Agentes Distribuidos y Fractales usando DSS/VPL
    Agentes Distribuidos usando DSS/VPL
    Intérprete tipo Lisp usando DSS y VPL
    Ejemplo de Web Crawler usando DSS (Decentralized Software Services)
    Scribble Distribuido con Microsoft Robotics Developer Studio y DSS
    Algoritmos Genéticos con AjAgents y Concurrency and Coordination Runtime (CCR)

    Más enlaces sobre estos temas en:

    http://delicious.com/ajlopez/msrs
    http://delicious.com/ajlopez/dss
    http://delicious.com/ajlopez/ccr
    http://delicious.com/ajlopez/robotics

    Nos leemos!

    Angel "Java" Lopez
    http://www.ajlopez.com/

    Posted Wed, Sep 10 2008 14:17 by lopez | 3 comment(s)

    Matriz de Competencias de Programación

    La semana pasada, encontré una página interesante, describiendo:

    Program Competency Matrix

    El autor, Sijin Joseph, explica el origen de la matriz en su his post:

    Habiendo trabajado con programadores con una extrema varianza en sus habilidades, algunas veces siento que hay un gran falta de buenos programadores, pero cuando pieson sobre eso un poco más, me doy cuenta que no hay un corte claro, algunos de los programadores tienen áreas fuertas y si uno los destina a las tarea en esas áreas fuertas ellos tienden a desenvolverse bien. Así que comencé a pensar acerca de cómo podemos evaluar a un programador, he aquí el resultado…

    Como pueden ver en la página, la matriz tiene cuatro niveles repartidos en columnas, y filas agrupadas en categorías:

    • Ciencia de la Computación
    • Ingeniería de Software
    • Programación
    • Experiencia
    • Conocimiento

    Me gusta toda la matriz, déjenme mostrar algunas de mis filas preferidas, sus niveles, y mi auto evaluación:

    Conocimiento - Blogs

    1. Ha oído que existen pero no tiene tiempo para dedicarle.
    2. Lee blogs técnicos, de programación, de ingeniería de software y escucha podcasts regularmente.
    3. Mantiene un blog con artículos útiles y herramientas que ha ido coleccionando
    4. Mantiene un blog con opiniones personales y pensamientos sobre programación que comparte con los demás

    Yo estoy cerca del 4.

    Conocimiento - Libros

    1. La serie Unleashed series, aprenda en 21 d[ias, en 24 horas, la serie for dummies...
    2. Code Complete, Don't Make me Think, Mastering Regular Expressions
    3. Design Patterns, Peopleware, Programming Pearls, Algorithm Design Manual, Pragmatic Programmer, Mythical Man month
    4. Structure and Interpretation of Computer Programs, Concepts Techniques, Models of Computer Programming, Art of Computer Programming, Database systems , de C. J Date, Thinking Forth, Little Schemer

    Me faltan algunos libros, pero de nuevo, estoy más cerca de 4.

    Conocimiento - Herramientas

    1. Limitado a IDEs primarias (VS.Net, Eclipse etc.)
    2. Conoce algunas alternativas a las herramientas populares.
    3. Buen conocimiento de editores, depuradores, IDEs, alternativas de código abierto, etc, etc. Por ejemplo, alguien que conoce muchas de las herramientas que lista Scott Hanselman en su lista de power tools. Ha usado herramientas de ORM (Object Relational Mapping).
    4. Ha escrito herramientas, scripts, gana puntos si fueron publicadas.

    Bien, me veo entre 2 y 3, pero he escrito y publicado herramientas, así que también me siento cerca de 4.

    Conocimiento - Conocimiento interno de la plataforma

    1. Cero conocimiento interno de la plataforma
    2. Tiene conocimientos básicos de cómo la plataforma trabaja internamente
    3. Profundo conocimiento del funcionamiento interno de la plataforma, puede visualizar cómo la plataforma toma un programa y lo convierte en código ejecutable.
    4. Ha escrito herramientas para mejorar o proveer la información sobre el funcionamiento interno de la plataforma. Por ejemplo, desensambladores, decompiladores, depuradores, etc.

    Estoy en 3.

    Experiencia - Años de experiencia profesional

    1. 1 año
    2. 2 a 5 años
    3. 6 a 9 años
    4. 10 o más años

    Absolutamente en 4, pero creo que ya merezco otro nivel.... 30 años son un montón... :-)

    Programación - Organización del árbol de código fuente

    1. Todo en una sola carpeta
    2. Separación básica de código en carpetas lógicas.
    3. Sin dependencias circulares, binarios, librerías, documentos, builds, código de terceras partes, todo organizado en sus carpetas
    4. Disposición física del árbol de código corresponde a la jerarquía lógica y a la organización del programa. Los nombres de directorios dan una idea del diseo del sistema.

    Veo que estoy entre 3 y 4.

    Programación - Organización del código en un archivo

    1. No hay evidencia de organización en el archivo
    2. Los métodos estan agrupados lógicamente o por accesibilidad
    3. Código es agrupado en regiones, bien comentado con referencias a otros archivos de código fuente
    4. El archivo tiene un encabezamiento con la licencia, un resumen, bien comentado, uso consistente de los espacios en blancos. El archivo se ve hermoso.

    Hmmm.... Me pondría en 2.

    Programación - Comunicación

    1. No puede expresar pensamientos/ideas a sus pares. Pobre ortografía y gramática.
    2. Los pares pueden entender lo que dice. Buen ortografía y gramática.
    3. Puede comunicarse efectivamente con sus pares
    4. Puede comprender y comunicar pensamientos/diseño/ideas/especificaciones de una manera no ambigua, y puede ajustar su comunicación según el contexto

    Me gusta esta fila. Estoy cerca del 4 (en españo), me reparto en 1 y 2 en inglés hablado, y entre 2 y 3 en inglés escrito. El autor de la matriz comenta en esta fila:

    Este es un criterio frecuentemente descuidado pero crítico para juzgar a un programador. Con el incremento del outsourcing en las tareas de programación a lugares donde el inglés no es la lengua nativa, este tema se ha vuelto más importante. Conozco varios proyectos que fallaron porque los programadores no pudieron entender cuál era la intencion de una comunicación....

    Ciencia de la Computación - Programación de Sistemas (de base)

    1. No conoce qué es un compilador, enlazar o intérprete
    2. Conocimiento básico de compiladores, enlazadores, intérpretes. Entiende qué es un código de assembler, y cómo funcionan las cosas a nivel de hardware. Algún conocimiento de memoria virtual y paginado.
    3. Entiende las diferencias de modo kernel vs modo usuario, multi threading, primitivas de sincronización y cómo son implementadas, puede leer código de assembler. Entiende cómo funcionan las redes, entiende de protocolos de red y programación a nivel de sockets.
    4. Entiende toda la pila de programación, hardware (CPU + memoria + cache + interrupciones + microcódigo), código binario, assembly, enlazamiento estático y dinámico, compulación, interpretación, compilación JIT (Just In Time), recollección de basura (garbage collection), heap, stack, direccionamiento de memoria…..

    Cuando escribí este artículo en inglés, me evalué en 3. Ahora pienso que estoy tranquilamente en 4.

    Ingeniería de Software - Testeo automático

    1. Piensa que todo el testing es el trabajo del tester
    2. Ha escrito tests unitarios automáticos y arma buenos casos de tests unitarios para el código que escribe
    3. Ha escrito código a la manera de TDD (primero el test, luego el código)
    4. Entiende y es capaz de armar tests automáticos funcionales, de carga, de rendimiento y de interfaz de usuario

    Estoy en 3, habiendo trabajado un poco en 4.

    Bueno, hay muchas más filas a evaluar. Pero no es sólo importante evaluarnos cómo estamos hoy. Si Ud. se preocupa por la mejora continua, debe evaluar su nivel actual en cada fila, planear cómo incrementar cada nivel, aun en los que tiene 4, y revisitar esta evaluación regularmente. Busque ayuda en sus compañeros de trabajo, y en otros programadores. Pista: ocúpese de la fila con el nivel más bajo, primero.

    Nos leemos!

    Angel "Java" Lopez
    http://www.ajlopez.com

    Posted Tue, Sep 9 2008 12:38 by lopez | 6 comment(s)

    Microsoft Extensibility Framework en codeplex

    El viernes pasado apareció la primera entrega del

    Microsoft Extensibility Framework (en codeplex)

    Es un proyecto .NET de Microsoft, que será incorporado dentro del propio framework de .NET en el futuro. Pueden visitar la página y bajarse el código. Necesitan un Visual Studio 2008 y .NET 3.5 instalado para poder usarlo. Viene con el código fuente, y el compilado de tres ejemplos.

    El problema que ataca es: necesitamos una aplicación extensible, que soporte la incorporación dinámica de plugins. Uno de los ejemplos es el clásico juego del Tetris, esta vez en versión WPF (Windows Presentation Foundation). El punto de extensibilidad son las propias piezas. Pueden codificar una librería .DLL con la definición de nuevas piezas, y se pueden agregar al juego andando. Los otros dos ejemplos son un Outlook y Windows Explorer extensibles.

    Este problema MEF lo resuelve dando:

    • Una forma estándar de consumir extensiones external en una aplicación. También permite que una aplicación se exponsa como extensión de otra. Una extensión puede depender de otra, y MEF se ocupa de conectarlas.
    • Una forma de descubrir y cargas las extensiones disponibles.
    • Atributos que permiten colocar metadata adicional en los componentes de la extensión.

    Cómo funciona

    Hay un nuevo namespace System.ComponentModel.Composition. El ComposablePart es el elemento básico de este namespace. Una ComposablePart ofrece uno o varios Exports, y a su vez, puede depender de uno o más Imports, que son servicios provistos por otras partes. Generalmente, una Part ofrece una instancia de un tipo que le indicamos, para que sea consumida por el resto del sistema, pero como otras partes de MEF, esta conducta puede ser cambiada.

    Hay Contracts, que son textos, strings, que describen un contrato que sirve de puente entre los Export e Import. Hay Catalogs, que da acceso a las ComposableParts que contengan. Pero también existe el concepto de Container, donde se colocan las partes y catálogos que a uno le interesa. El contenedor resuelve las dependencias de las partes y expone las partes exportadas.

    No hace falta armar las ComposablePart, sino que podemos agregar atributos a nuestras clases, para indicar que exportan tal tipo de parte. Por ejemplo, una nueva pieza en el Tetris, se puede declarar como:

    [Export(typeof(IShape))] [Shape(ShapeType.GameShape, "Diagonal shape", 0)] [CompositionOptions(CreationPolicy = CreationPolicy.Factory)] public class Diagonal : RegularShape {

    El atributo Export es el que hace que MEF la reconozca como una parte proveedora de IShape, una interface que el resto del juego utiliza para interactuar con una pieza.

    El uso de atributos hace que MEF pueda determinar las parts, imports y exports, simplemente descubriéndolas en un assembly, usando reflection.

    Un ejemplo

    Aclaremos un poco los conceptos de arriba, con un pequeño ejemplo. Supongamos que nuestra aplicación tiene que usar una parte que sea capaz de enviar un mensaje, a algun destino. La interfaz será:

    public interface IMessageSender { void Send(string message); }

    En nuestro objeto de aplicación, podemos necesitar ese servicio desde una propiedad marcada con Import:

    [Import] public IMessageSender MessageSender { get; set; }

    Tenemos una implementación concreta en:

    [Export(typeof(IMessageSender))] public class EmailSender : IMessageSender { public void Send(string message) { Console.WriteLine(message); } }

    Usando un container, agregamos las partes (nuestro objeto aplicación, nuestro proveedor de servicio de envío de mensaje):

    private void Compose() { var container = new CompositionContainer(); container.AddPart(new EmailSender()); container.AddPart(this); container.Compose(); }

    El método Compose() del contenedor, es el que se encarga de conectar las partes que agregamos, resolviendo los imports y exports.

    Para más información, visitar:

    Overview para aprender más sobre MEF

    Guide con la guía de programación

    Samples descripción de los ejemplos

    Downloads para bajar un .zip con el código y ejecutable.

    Pueden leer los blogs del equipo, como

    MEF on CodePlex de Krzysztof Cwalina

    MEF Making its debut on Codeplex de Glenn Block

    MEF and more de Hamilton Verissimo, el desarrollador fundador del project Castle

    Managed Extensibility Framework on CodePlex de Brad Adams

    Consultas y retroalimentación del proyecto en el foro de MSDN:

    http://forums.msdn.microsoft.com/en-US/MEFramework/threads/

    El MEF ha comenzado ha ser probado por la comunidad. Un aviso temprano de Miguel de Icaza, menciona que la licencia impide su uso fuera de la plataforma Windows.

    Nos leemos!

    Angel "Java" Lopez
    http://www.ajlopez.com/

    Posted Mon, Sep 8 2008 10:19 by lopez | with no comments

    Filed under:

    Proyecto Androide

    Quisiera hoy presentar un proyecto de robótica, que se está encarando desde mi país Argentina. Es un proyecto dedicado a crear un robot androide de tamaño aproximado al de una persona. La idea es formar una comunidad de diseño y desarrollo en hardware, software, y para eso, la gente del proyecto invita a los interesados a participar.

    La página del proyecto es:

    Proyecto Androide

    El dibujo que acompaña a este post no es el definitivo, es un dibujo que se irá adaptando a lo que se vaya diseñando en el proyecto. Está en sus inicios. Si no conocen del tema, pueden visitar la página de categorías del wiki, donde encontraran informacion sobre Algoritmos, Biomecánica, Comunicación, Cinemática, Programas, Participantes, Reuniones, entre otros temas.

    El proyecto comenzó en marzo de este año, 2008, así que estan dando los primeros pasos. Espero que puedan avanzar con paso firme.

    El proyecto está albergado en la página de

    Robots - Argentina: Pasión por la robótica

    Encontraran ahí varios artículos sobre motores, actuadores, comunicación, procesadores, sensores, energía, circuitos, robots.

    Por ejemplo:

    La historia de mi primer robot
    Baterías para alimentación de robots
    Androides de todo el mundo
    Se vienen los robots
    Ejemplo de un brazo robótico
    Lógica de detección de atascos
    Visión estereoscópica en tiempo real con una cámara única
    Sensores de presión
    Sensores de contacto
    Piel robótica
    Manos robóticas
    Músculos de alambre (o alambre muscular)
    Músculos neumáticos (o músculos de aire)
    Ejemplo de un brazo robótico

    y más.

    Tienen una lista de Desarrolladores de Robots:

    http://ar.groups.yahoo.com/group/robots_desarrolladores/

    donde leo:

    El grupo Desarrolladores de Robots es un espacio para compartir datos y experiencias sobre proyectos de robótica, ayudarnos en cuestiones técnicas en el desarrollo de nuestro robot, facilitar proyectos en conjunto sobre robots, ayudarnos con información para conocer mejor los componentes y saber cómo obtenerlos, estar informados sobre las actividades relacionadas con nuestra pasión y conocernos y alimentar una amistad que conduzca al crecimiento personal y general en esta disciplina.

    Esperamos un nutrido intercambio de mensajes sobre robots, robótica y automatización en general, electrónica, sistemas digitales, microcontroladores, microcomputadores, microprocesadores, memorias, periféricos, comunicación, controles remotos, links de infrarrojo, links de RF, sensores, actuadores, motores, partes mecánicas, inteligencia artificial, programación en todos los lenguajes: Assembler, Basic, C, visual, sin olvidar las complejidades y dificultades de la parte mecánica, que requiere precisión y cuyo logro cuesta tanto trabajo.

    Nos leemos!

    Angel "Java" Lopez
    http://www.ajlopez.com/

    Posted Sat, Sep 6 2008 14:42 by lopez | 2 comment(s)

    Filed under:

    Scrum Práctico

    Gracias al Microsoft User Group de Argentina, en especial a Oscar Turquet, Mónica y Sandra, ayer estuve dando un día completo de Scrum, con algo de teoría y varias horas de práctica.

    Los asistentes se dividieron en 5 grupos de 5-6 personas, y desarrollamos un ejercicio, un proyecto adoptando Scrum, con tres sprints (Iteraciones) de 3 días simulados de 10 minutos, más un Sprint Planning de 10 minutos, más una presentación al final, una Sprint review. Durante el trabajo fuimos mejorando en algunas prácticas, y al final hicimos una retrospectiva grupal. Estuve usando un ejemplo de Tobias Meyer, que permite tanto aplicar Scrum como pensar sobre el propio proceso.

    Es interesante ver cómo los equipos se van autoorganizando, y descubriendo y enfrentando las dificultades que encuentran en el camino. Creo que con la práctica por lo menos de un ejercicio, queda más claro porqué de cada ceremonia de Scrum (que se puede explicar en 1 minuto, si queremos). Ahí con un ejercicio concreto, con grupos formados en el momento, tal vez con gente que no se conoce, es donde se ve cómo funciona Scrum.

    Yo veo que Scrum funciona si tenemos la gente adecuada ("the right people") y el ambiente adecuado (al equipo se protege, por ejemplo). Solamente podemos decir que hemos intentado Scrum si lo adoptamos al principio de forma completa. Si sólo tomamos algunas cosas, no es Scrum. Con el tiempo y la experiencia, podemos sentarnos y ver claramente qué modificamos de Scrum para nuestra organización, pero en principio, recomendaría adoptar Scrum para un proyecto, de forma completa.

    No hace falta que toda la organización adopte Scrum, pero es necesario que la gerencia, y el cliente, entiendan perfectamente el proceso. Y que el "product owner" sepa armar un backlog de producto saludable, y bien priorizado.

    Los enlaces que mencioné, y bibliografía adicional, ya estan incluídos en mi anterior post:

    Explicando Scrum

    Agrego hoy la lista de desarrollo ágil de latinoamérica:

    laasd · Latin America Agile Software Development (mensajes en español)

    y el código del sistema que vimos en línea para ingresar backlogs, commitments y llevar métricas:

    http://www.codeplex.com/ScrumLite

    La presentación actual está en mi Skydrive:

    Scrum200802-2003.ppt (formato PowerPoint 2003, 7Megas)

    Scrum200802.pptx (7Megas)

    Scrum200801.ppt (Presentación original, más liviana, con menos gráficos, 1.2M)

    Agradezco a Diego Poza, por haber mejorado y ampliado la presentación original.

    Más enlaces sobre estos temas en:

    Agiles 2008 en Argentina

    Post sobre Scrum en este blog

    http://del.icio.us/ajlopez/scrum

    http://del.icio.us/ajlopez/agile

    Nos leemos!

    Angel "Java" Lopez
    http://www.ajlopez.com/

    Posted Thu, Sep 4 2008 13:36 by lopez | 1 comment(s)

    El camino hacia el Modelo de Dominio y Domain-Driven Design

    Por años, la comunidad de desarrolo de software ha luchado contra la complejidad y el cambio. El desarrollo de software es uno de las actividades humanas con más niveles de detalle: debemos captar la imagen completa del sistema, y a la vez, tomar en cuenta cada pequeño detalle. Un desarrollador o un equipo de desarrolladores tienen que manejajar un montón de concptos, estilos de arquitectura, patrones de diseño e implementación, lenguajes, tecnologías, mejores prácticas y aún más: tiene que ejercitar los "soft skills" de comunicación con otros interesados en el proyecto.

    Todo esto puede ser una tarea intimidante.

    Muchos paradigmas emergieron en las últimas décadas, notablemente el orientado a objeto. Pero toma caminos divergentes: uno fue el purismo académico, con Smalltalkers y otros, que hicieron una gran tarea difundiendo objetos, pero que siguieron trabajando en aplicaciones, digamos, de nicho, no cruzando el abismo para llegar a la corriente principal de desarrollo (supongo que la fragmentación de Smalltalk en diverss dialectos fue una de las razones para el estado actual de la comunidad ST). No me malentiendan: Smalltalk tiene un comunidad fuerte y viva, pero no es uno de las tecnologías con muchas aplicaciones empresariales para mostrar.

    C++ fue el primer lenguaje popular que dió "objetos para las masas", pero con la aparición de tecnologías complicadas (¿recuerdan la API desnuda de Windows? ¿O cualquier API de GUI?) y la explosión del mercado de PC, la corriente principal de desarrollo fue tomada por lenguajes derivados de xBase, y Delphi y Visual Basic, este último no tiene soporte de objetos hasta la versión 3, y nunca soporte de herencia. (Visual Basic fue un "matador" de ideas hermosas, como el lenguaje Actor: una extensión orientada a objetos del lenguaje Forth, con soporte nativo de GUI, implementado en Windows). (Sí, también tomemos nota de COBOL: este lenguaje fue y aún es el lenguaje principal en muchos ambientes).

    Java hizo su aparición a mediados de los 90, dando aire fresco a la programación (yo nunca programé con VB 6.0: después de encontrar el paraíso Java, quién quería lidiar con Apartment Thread Models y todo el lío COM). Teníamos una librería de clases, verdaderos objetos, pero más: nosotros fuimos bendecidos por un "garbage collector", recolector de basura. Los nuevo "patrones de diseño" podían ser adoptados de forma masiva. Los objetos comienzan a estar en todas partes. Aparecen frameworks.

    Pero algo estaba faltando: aunque los frameworks tomaron ventaja del uso de objetos, las implementaciones de negociones de muchas aplicaciones no reflejaban las nuevas capacidades. El elusivo Modelo de Dominio era un "santo grial" que no era fácil de encontrar. El trabajo de Sun con J2EE fué un fracaso parcial para armar modelos de dominio en Java. Cuando .NET nace, Microsoft no repite el error, y en sus primeros ejemplos y escritos de  Pattern and Practices, no usan ninguna de los ideas de Modelo de Dominio (supongo que todavía son reluctantes a adoptar un Modelo de Dominio, LINQ to SQL es aún una bestia orientada a datos, la esperanza que tenemos es el Entity Framework).

    La comunidad de Java tiene un gran conjunto de herramientas y librerías de código abierto, desde Ant a Maven a Tomcat y más. La simplicidad de la programación POJO (Plain Old Java Objects), junto con soluciones no intrusivas de persistencia (notablemente Hibernate), tomó un nuevo camino para alcanzar una más clara implementación de un modelo de dominio.

    .NET entró tarde en el juego: mucha de las herramientas y ejemplos en el mundo .NET eran centradas u orientadas a datos, con datasets, y características de enlace a datos en todas las presentaciones (WinForms y ASP.NET). La comunidad .NET aprendió de la experiencia de la comunidad de Java, y en los últimos años, tenemos las ideas de Modelo de Dominio implementado en ambos mundos.

    Eric Evans escribió un libro seminal sobre sus ideas de Domain-Driven Development, donde el Modelo de Dominio no es un artefacto más, sino el corazón del software a desarrollar. El va más allá de Modelo de Dominio, describiendo nuevos patrones y maneras de implementarlo. El libro explica el proceso para crear y descubrir un modelo, usando un lenguaje ubicuo (compartido con los usuarios), y cómo mejorar el modelo a lo largo del proceso de desarrollo.

    Implementaciones de modelo de dominio, y DDD, son grandes tópicos a tratar. Quiero comenzar a escribir sobre esos temas, discutiendo varios puntos, y dando ejemplos concretos en Java y .NET. No es una tarea fácil, así que no esperen un post diario: el trabajo tomará tiempo.

    Por ahora, pueden visitar mi colección de enlaces sobre DDD en:

    http://del.icio.us/ajlopez/ddd

    Algunos de mis anteriores posts sobre DDD:

    Mini Book Domain Driven Design Quickly

    Domain-Driven Design Resources

    Enlaces y Recursos Domain-Driven Design

    Domain-Driven Design

    Nos leemos!

    Angel "Java" Lopez
    http://www.ajlopez.com

    Posted Wed, Sep 3 2008 11:34 by lopez | 1 comment(s)

    El browser de Google: proyecto Chrome

    Ayer apareció un rumor en:

    Google Chrome, Google’s Browser Project

    confirmado, al parecer, por el blog oficial de Google con:

    A fresh take on the browser

    La difusión de sus características e historias, se hizo en formato de cómic, en varios cuadros, el primero es:

    Es interesante ver cómo Google sigue lo que predica de "launch early and iterate".

    Creo que más allá de algunos temas cosméticos y de lanzamiento, lo principal a destacar es la Virtual Machine de JavaScript V8. Por lo anunciado hasta ahora, tendrá soporte de múltiples threads, tendrá un manejador de tareas. Me imagino que Ajax ya se basará solamente en Javascript, sin necesidad del componente XMLHttpRequest.

    Pero si implementan "bien" a Javascript, con la suficiente potencia, seguramente podrá compilarse en Javascript a otros programas escritos en lenguajes, como C#, Smalltalk, Ruby (ya hay implementaciones de esto en Javascript "común"), de una forma más elegante y poderosa. Si consiguen un sandbox seguro para almacenar datos localmente, se abren más posibilidades.

    Esto cambiará el mercado de desarrollo SaaS: me imagino aplicaciones Chrome trabajando desconectadas, o conectadas. Pero eso es futurología.

    Más concreto es la aparición de un nuevo Javascript. Pero creo que solamente tomará impulso, si Firefox y IE adoptan con el tiempo a esa nueva implementación. Lo que puede ser algo difícil. Es como con Ajax: hasta que no hubo soporte de Javascript y XMLHttpRequest en los mayores browsers, la tecnología no despegó.

    Otro camino que se abre, es que se pueda usar ese lenguaje dinámico fuera del browser Chrome, como una VM de aplicaciones Javascript V8, más liviano y multiplataforma (multilenguaje por abajo, es decir, Smalltalk, C#, Ruby.... todos reimplementables en JSV8).

    Nos leemos!

    Angel "Java" Lopez
    http://www.ajlopez.com/

    Posted Tue, Sep 2 2008 14:11 by lopez | with no comments