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

January 2010 - Posts

Queue Channels en AjSharp

Hace una semanas, implementé channels en mi intérprete AjSharp. Pueden leer sobre el tema en:

Channels and GoRoutines in AjSharp (part 1)
Channels and GoRoutines in AjSharp (part 2)

Canales y GoRoutines en AjSharp (Part 1)
Canales y GoRoutines en AjSharp (Part 2)

Si uno lee el valor de un canal, y no hay valor disponible, el thread que está tratando de leer se bloquea hasta que el valor esté disponible. Esta es una manera de sincronizar consumidores y productores que operan sobre el canal. Pero algunas veces queremos poner un valor en un canal y continua, sin bloqueo. Para eso, agregué una “queue channel” (podría llamarla queued channel): pueden poner N valores en el canal sin bloqueo, porque se van guardando en una cola interna. El tamaño de la cola se determina en un parámetro en el constructor. La cola está limitada en tamaño para poder preservar sus capacidades de sincronizació.

El nombre de la nueva clase es QueueChannel. Un test:

        [TestMethod]
        public void CreateAndUseQueueChannelWithTenElements()
        {
            QueueChannel channel = new QueueChannel(10);
            for (int k = 1; k <= 10; k++)
                channel.Send(k);
            for (int k = 1; k <= 10; k++)
                Assert.AreEqual(k, channel.Receive());
        }

El canal recibe 10 valores sin bloquearse. Si enviamos más valores, debemos usar otro thread:

        [TestMethod]
        public void CreateAndUseQueueChannelWithMoreEntriesThanSize()
        {
            QueueChannel channel = new QueueChannel(10);
            Thread thread = new Thread(new ThreadStart(delegate()
            {
                for (int k = 1; k <= 20; k++)
                    channel.Send(k);
            }));
            thread.Start();
            for (int k = 1; k <= 20; k++)
                Assert.AreEqual(k, channel.Receive());
        }

Para probarlo en un ejemplo, reescribí el ejemplo de números primos usando queue channels:

numbers = new QueueChannel(10);
running = true;
k = 1;
go while(running) { k++; numbers <- k; }
function filter(in, out, prime)
{
  while (true) 
  {
    value = <-in;
    if (value % prime)
      out <- value;
  }
}
function makefilter(channel, number)
{
  newchannel = new QueueChannel(10);
  go filter(channel, newchannel, number);
  return newchannel;
}
channel = numbers;
number = <-channel;
while (number < 1000) 
{
  PrintLine("Prime " + number);
  
  channel = makefilter(channel, number);
  
  number = <-channel;
}
running = false;

El código está en mi Google code project:

http://code.google.com/p/ajcodekatas/source/browse/#svn/trunk/AjLanguage

Mi motivación para un queue channel apareció en ejemplo de algoritmo genético en paralelo, que sufría de demasiados bloqueos. Veo que un buen algoritmo no necesitaría colas, pero si uno tiene muchos consumidores y productores, y un thread produce valores para ser colocados en más de un canal, podría pasar que al colocar el valor en el canal A, no lleguemos a entregar el valor en el canal B, por bloqueo en la primera operación. Una forma de evitar el bloqueo es usando el comando go:

go channel <- newvalue;

Pero me parece que es demasiado lanzar una goroutine solamente para alimentar un canal.

Tendría que presentar el algoritmo genético en paralelo (que ya hace unos meses presenté), y escribir algunas ideas para implementar un actor model en AjSharp, y usar agentes distribuidos.

Nos leemos!

Angel “Java” Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez

Posted Fri, Jan 29 2010 10:47 by lopez | 1 comment(s)

AjSharp: Implementando Futures

Había implementado canales en mi intérprete AjSharp. Describí el trabajo y ejemplos en:

Channels and GoRoutines in AjSharp (part 1)
Channels and GoRoutines in AjSharp (part 2)

Canales y GoRoutines en AjSharp (Part 1)
Canales y GoRoutines en AjSharp (Part 2)

También los usé directamente en C#:

GoRoutines y Canales en C#

Podría usar canales para implementar futures. Una opción es usar Task Parallel Library de Microsoft, pero entonces debería usar .NET 4: aparentemente, la librería original no está más disponible para .NET 3.x. Imagino que podría aprovecharme de las nuevas clases del nuevo framework, pero mientras, quiero explorar las ideas de programación con futures por mi cuenta.

Los canales pueden ser usados para implementar el proceso de futures:

channel = new Channel();
go channel <- SomeLengthlyCalculation();
// .. more process
result = <- channel;

Pero los canales han sido diseñados para resolver otros problemas: para tener varios valores durante su vida, y ser usados como objetos de sincronización entre productores y consumidores de esos valores. La variable channel del ejemplo de arriba, si se usara como un future, podría ser consultada sólo una vez. Es un pequeño problema, pero señala una diferencia entre canales y futures.

Así, escribí una nueva clase nativa, accesible desde programas AjSharp, llamada Future:

    public class Future : IReference
    {
        private object value;
        private ManualResetEvent handle = new ManualResetEvent(false);
        private bool set = false;
        public void SetValue(object value)
        {
            lock (this)
            {
                if (this.set)
                    throw new InvalidOperationException("Future value already calculated");
                set = true;
                this.value = value;
                this.handle.Set();
            }
        }
        public object GetValue()
        {
            this.handle.WaitOne();
            return this.value;
        }
    }

En la versión actual en el trunk, la interface IReference (que contiene méteodos SetValue, GetValue) está implementada por la clase Channel. Los operadores AjSharp a <- b, a = <-b, son mapeados a esos métodos. Entonces podemos usar Futures de esta forma:

future = new Future();
go future <- SomeLenghtlyProcess();
// ... more process
result = <-future;
result2 = <-future;

La consulta del valor del future es explícita, usando el operador <-. De esta forma, podemos pasar la variable future a cualquier otra función, usando el nombre, sin ver todavía su valor. Podría eliminar el go en el seteo de la variable future, asumiendo que el valor a la derecha de ese valor se calcula en paralelo. Pero prefiero hacer que el paralelismo quede explícito, usando el comando go.

Esta es una mejora menor en el procesamiento en paralelo de AjSharp. Estoy trabajando en queue channels: channels que soporten el manejo de más de un valor, sin bloquearse. Pueden ver el código y ejemplos en:

http://code.google.com/p/ajcodekatas/source/browse/#svn/trunk/AjLanguage

Quiero implementar agentes, para soportar la programación basada en el actor model. Podría ser interesante tener a la palabra agent como palabra clave, como la palabra class. Y que esos agentes puedan ser ejecutados en máquinas remotas.

Nos leemos!

Angel “Java” Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez

Posted Thu, Jan 28 2010 10:57 by lopez | with no comments

Nerddinner en Tandil

Es bueno enterarse que hay más NerdDinners en mi país Argentina. Ahora, mañana miércoles, viene una más, en Tandil, provincia de Buenos Aires. Más información en:

http://www.nerddinner.com/1606

Me informa el bueno de @cwalzer que no es la primera, debe ser como la quinta que organizan por ahí. Ya tuvimos dos en Buenos Aires, leer:

Segunda Nerddinner en Buenos Aires

Tandil tiene un actividad de desarrollo importante, movilizada por la presencia de empresas y, en particular, por el motor que es la Universidad del Centro. Ya estuve dos veces en la ciudad, dando alguna charla:

ASP.NET y Ajax en Tandil, Buenos Aires
Generación de Código y AjGenesis en Tandil

@cwalzer hace un tiempo que se mudó a Tandil, donde se vive una vida distinta de la que se ve en Buenos Aires. Me cuenta que hay una gran actividad inmobiliaria, lo que revela que Tandil está creciendo como centro concentrador de actividades.

Tiene evidencia de anteriores reuniones en Tandil en:

http://twitpic.com/j0jg2
http://twitpic.com/fehpq

Jeje… parece que le dan al asado por ahí, algo más difícil de encontrar por aquí (por lo menos a un precio que no sea de turista).

Conocen otras Nerddinners? Hay alguna por su zona?

Nos leemos!

Angel “Java” Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez

Posted Tue, Jan 26 2010 10:43 by lopez | 4 comment(s)

ALT.NET Hispano VAN (reunión virtual): IronRuby

Gracias a la comunidad ALT.NET Hispano, este sábado 23 de enero, a las 18hs GMT (acá en Buenos Aires, Argentina, 15hs). El tema es IronRuby y será presentado por Mario Chavez.

Mario presentó el temario en la lista de ALT.NET Hispano, así:

Que es lo que pueden esperar de esta VAN?
- Lenguaje Ruby
+ Que es
- Ironruby
+ Que es
+ Variables
+ Metodos
+ Clases
+ Sintaxis sugar
+ Expresiones regulares
- Aplicaciones de Ruby con Ironruby
+ BDD con Rspec
+ BDD con Cucumber
+ Sinatra DSL
+ Rails
- Integracion con .NET
+ BDD de codigo C#
+ Hosting de Ruby en C#
+ ASP.NET MVC con Ruby
+ Silverlight con Ruby

Pueden leer el post de Mario Chavez sobre sus actividades de este mes con IronRuby: Webcasts sobre IronRuby en Enero.

Si no conocen IronRuby, comiencen desde:

http://www.codeplex.com/IronPython

Mis enlaces sobre el tema:

http://delicious.com/ajlopez/ironruby
http://delicious.com/ajlopez/ruby
http://delicious.com/ajlopez/dlr

(yo tendría que comenzar a jugar con Dinamic Language Runtime, DLR, o hacerme uno … :-)

Vean también Sinatra:

http://www.sinatrarb.com/

(sí, sí, hay AjRuby, pero todavía en inception… ;-) .. leer TDD and Code Kata: Writing a lexer for AjRuby)

Más información sobre cómo asistir a la reunión virtual, software necesario, enlaces: http://altnet-hispano.pbworks.com/Descripcion-de-Reuniones

Nos leemos!

Angel “Java” Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez

Posted Thu, Jan 21 2010 11:32 by lopez | with no comments

Tales from the Scrum: Agile/Scrum es difícil?

Hace un tiempo, seguramente via un mensaje en Twitter, me encontré con el post Agile/Pervagile on Slashdot en el blog multi-autor de Agile Advice – Working With Agile Methods (Scrum, OpenAgile, Lean). Es una lectura interesante. El autor presenta una descripción de lo que llama Pervagile, the Perverted Agile, lo ágil pervertido por malas prácticas. Muchas compañías dicen que están usando Agile, con Scrum o algo parecido, pero, en realidad, su adopción es parcial. El autor menciona otras desviaciones, que tienen nombres como: Scrumbutt, Waterscrum, Scrummerfall, pero esos temas merence un post aparte.

Pero hoy, quiero comentar sobre el párrafo (disculpen que no traduzca):

Agile is Hard

Okay, I’m actually being a little dis-honest.  The real truth is that doing agile is extremely, exceptionally, agonizingly difficult (for most people in most  organizations).  Why?  Because agile is not just another process to roll out.  It is, as has been mentioned in numerous places, a deep cultural change.  Agile is actually a liberation movement for people involved in software development.  Like most movements, however, it has been subject to corruptive forces.

Bien, cierto, pero… Quiero moderar las afirmaciones de arriba, esta vez en el contexto de la aplicación de Scrum (no de Agil en general). Si estamos involucrados en la introducción de Scrum por primera vez en su compañía, claro que va a necesitar un cambio cultural, pero veo que no tendría que ser profundo (“deep” como dice arriba). Lo que necesitamos es un grupo de gente proactiva que componga el primer equipo, un buen ScrumMaster que maneje la introducción de Scrum, y un Product Owner que conozca su función. Y (y no es un Y pequeño) el soporte de parte de la gerencia, para protejer al equipo de intereferencias externas, Y ESPECIALMENTE el soporte al Product Owner: protejerlo/a de las presiones de otros genertes, fuerzas políticas, que podrían alterar las prioridades en el Product Backlog, o que pudieran intereferir en el medio del Sprint. El resto de la compañía pueden seguir trabajando a la vieja usanza. Pero necesitamos que nuestro primer proyecto sea protejido. Necesita protección y cuidado. No un gran cambio cultural. El cambio en el resto de la compañía podría ser progresivo. Y el cambio en el equipo (pensando en que es su primer encuentro como miembros de un Scrum) sería progresivo, ayudado por un ScrumMaster experimentado.

Nos leemos!

Angel “Java” Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez

Posted Wed, Jan 20 2010 9:37 by lopez | with no comments

Resultado de la VAN ALT.NET Hispano sobre Domain-Driven Design

Gracias a la comunidad de ALT.NET Hispano, he podido presentar el tema Domain-Driven Design, como anunciara hace un tiempo en:

ALT.NET Hispano VAN (Reunión Virtual): Domain-Driven Design

Y ahora, la comunidad se ha tomado el trabajo de escribir los principales puntos, y editar y publicar el video de la presentación y la charla. Pueden verlo en:

ALT.NET Hispano VAN 2009-12-19 Domain-Driven Design

En la presentación, comenté los principales puntos (DDD daría para varias horas), pero no fue sólo slides, sino que comentamos el código del proyecto: http://code.google.com/p/ndddsample

Como decía, DDD es un gran tema, que seguramente dará para más presentaciones en detalle, y más ejemplos de implementación. Por un lado, el uso de objetos y dominio estuvo desde temprano presente en el ambiente Java, pero por razones históricas, al llegar .NET no se hizo hincapié en el tema de armar un dominio, sino que se puso énfasis en los datos, más o menos directos.

Igualmente, el problema no es armar un dominio con objetos, sino llevarlo a una implementación exitosa, donde el dominio pueda convivir con tecnologías de todos los días, como bases de datos relacionales, concurrencia de usuarios, interfaces de presentación de distinto tipo, etc…. Por ejemplo, uno de los ejemplos de uso de dominio transparente, ha sido dado desde hace años, en el ambiente de la programación con Smalltalk. Pero hay que reconocer que esta tecnología no ha conseguido llegar al “mainstream” de desarrollo, y, en mi opinión, también se ha aislado de otros activos, como el acceso a base de datos y aplicaciones distribuidas.

Es aquí donde las ideas de Eric Evans y otros, abrieron la puerta para que hoy tengamos algunos patrones a adoptar o adaptar, para construir un dominio, e implementarlo de forma razonable, con lenguajes y tecnologías “mainstream”. Aún necesitamos varios artefactos para conseguirlo (me gustaría que fuera más simple, como en Smalltalk (no me olvido de mi post ¿Es tiempo de volver a la simplicidad?)), pero para un programador pragmático, las ideas de DDD tienen aplicación práctica.

Para mí, fue una feliz experiencia haber podido participar de este evento. Agradezco a todos lo que hicieron posible esto. Es notable lo que ha dado Internet y la Web en particular, para que podamos entre todos, compartir información, conocimiento, discutir opiniones, y aprender de cada uno algo. Y que las actividades como éstas, vayan quedando con “entregable”: no sólo una reunión, sino algo como resultado tangible.

Espero ir completando la página de la VAN con algunos enlaces más, pero veo que la gente de ALT.NET Hispano ha hecho un gran trabajo. Muchas gracias!

Nos leemos!

Angel “Java” Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez

Posted Sun, Jan 17 2010 12:45 by lopez | with no comments

Cursos de Scrum de Tobias Mayer en Buenos Aires

El bueno de Tobias Mayer visitará Buenos Aires en este mes de Enero. Fue Tobias mi instructor en el curso de Certified Scrum Master que tomé en el 2006. Tobias es conocido en todo el mundo ágil, habiendo trabajado en grupos de desarrollo usando Scrum, y dando cursos en varios países. Pueden ver un día de su trabajo como Scrum Master en:

Tales from the Scrum: un día en el equipo

Leo en el blog de Juan Gabardini el detalle de los cursos que dará Tobias:

Tobias Mayer ya ha venido varias veces a Argentina, y dio 6 cursos de CSM. Alan Cyment es el único CST hispanoparlante, y dio muchos cursos en Argentina. En enero Tobias nos visita en la semana del 25 al 26 y aprovechamos con varios actividades:

Enero 25: Scaling Scrum (gratuito) (x Tobias)
Enero 26: Consultas CSP (gratuito) (Alan y Tobias)
Enero 27: The Spirit of Scrum - (pago *) (x Tobias)

Enero 28: Improvisation for agile teams - (pago *) (facilitado por Alan Cyment, co-facilitado por Tobias)
(*) En ambos casos, cada día cuesta 220 usd + IVA. Tomando ambos cursos el costo es 330 usd + IVA - La facturación la realizará Agilar, que organiza estos eventos.

NOTA: inicialmente planificamos un CSM los días 25 y 26. Por el interés en los talleres avanzados, finalmente suspendimos ese CSM. Para los interesados en CSM, en marzo sr hará uno (Alan)

CSM se refiere a Certified Scrum Master. CSP es Certified Scrum Practicioner. Como se lee en http://www.agiles.org/agiles-bsas:

Luego de hacer un curso oficial de Scrum te convertis en CSM. Pero, más allá del valor de tomar el curso, todos sabemos que no es una "certificación" muy exigente. Por eso puede interesarte dar el próximo paso en las certificaciones de la Scrum Alliance: Certified Scrum Practicioner (http://www.scrumalliance.org/pages/certified_scrum_practitioner).

Les aconsejo que participen de alguno de estos cursos. Tener a Tobias es tener acceso a alguien que ha trabajado intensamente con Scrum, en distintas situaciones y proyectos.

Ya había traducido dos escritos de Tobias:

Tales from the Scrum: El corazón de Scrum
Tales from the Scrum: La esencia de Scrum

Para conocer más sobre Tobias visiten su blog Agile Thinking, y su iniciativa WelfareSCM (entramiento Scrum de bajo costo), también el video que grabó sobre el tema en InfoQ.

Y pueden seguirlo en Twitter como @tobiasmayer.

Nos leemos!

Angel “Java” Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez

Posted Fri, Jan 15 2010 9:58 by lopez | with no comments

Filed under: ,

Hacia un Hospital Information System de Código Abierto

Gracias a todos los que comentaron mi anterior post:

Hacia una Historia Clínica Digital de código abierto

Ha sido uno de los post que más comentarios ha recibido últimamente. Y me ha servido de mucho la información y los enlaces que me han pasado.

Desde entonces, he seguido investigando las ofertas de código abierto (y algunas comerciales) de sistemas relacionados con salud. Como comentaba ahí, una forma de que se adopte un sistema nuevo de código abierto, es que comience ha ser utilizado en algún caso real. En este tema, el target a alcanzar, en primer lugar, son clínicas, pequeñas instituciones, que no tengan el presupuesto para alcanzar a comprar un sistema comercial más caro. También ese tipo de target, sirve para ir probando en escala mediana el funcionamiento de un sistema.

Pero no quisiera que la primera implementación fuera para una institución en particular. El hacer un software sin cliente final, es un problema. Pero también es hacerlo para un cliente particular, porque es difícil armar el sistema manteniendo una claridad y flexibilidad que perdure, y que no se vea percutido por decisiones de diseño para satisfacer las necesidades inmediatas de un cliente. Es posible, pero he visto pocos casos de éxito siguiendo ese camino. Se puede hacer un núcleo, una prueba de concepto, sin tener un cliente final, y luego, una vez armado ese núcleo, simplísimo, ver de extenderlo, modificarlo (en poco o en mucho), ponerlo a prueba, cuando se llegue a un cliente real. En este caso, en este proyecto, preferiría un Fresh Start, y por un tiempo, basarse en lo que ya está publicado en otros sistemas.

Uno de los enlaces que mencionaba en mi anterior post era:

List of Open Source Healthcare Software

Ahí encontré la denominación

Hospital Information System

He ido coleccionado enlaces sobre salud (y sistemas de salud) en:

http://delicious.com/ajlopez/health
http://delicious.com/ajlopez/medicine

Ahí guardé varios enlaces a sistemas HIS (Hospital Information System) de código abierto, y dos o tres comerciales, así como ha sitios de información sobre medicamentos, drogas, contraindicaciones, etc... Una lista interesante es:

Hospital Information Systems (HIS): Commercial, free and open source list

como para tener una lista inicial referentes de la oferta actual. Por ahora, estuve viendo el gran trabajo de la gente de:

http://www.care2x.org/

Care2x integrates data, functions and workflows in a healthcare environment. It is currently composed of four major components. Each of these components can also function individually.

  • HIS - Hospital/Healthservice Information System
  • PM - Practice (GP) management
  • CDS - Central Data Server
  • HXP - Health Xchange Protocol

Our Mission

We strive to develop the most useful and practical integrated healthcare information system which is open for others to develop further.

The "Team"

The development team has currently more than 100 members with different skills and backgrounds. They come from more than 20 nations.

Me parece interesante el desarrollo de un HIS, porque:

  • No es trivial
  • Tiene desafíos de extensibilidad
  • Hay un mercado vertical ya existente
  • Hay referentes, contra los cuales medirse
  • Gran parte se podría ofrecer como SaaS (Software as a Service)

Por supuesto, un HIS completo es un trabajo de mucha gente, como demuestra el Care2x de arriba. Pero creo que puedo escribir por lo menos un núcleo, que considere las entidades más importantes, como pacientes, profesionales médicos, entidades financiadoras (Obras sociales, medicina prepaga), drogas y medicamentos, turnos, tratamiento ambulatorio, no sé si internación.

Las tecnologías candidatas que podría usar para encarar una prueba de concepto, son: WinForm, ASP.NET MVC, C#, SQL Server (he visto mucho hecho en Java, PHP y otras, pero no he encontrado tanto en .NET open source, igual tengo que seguir revisando enlaces). Me gustaría aplicar, por un lado, generación de código, y por otro, TDD, si fuera posible. Dejar abierto, en cuanto fuera posible, el consumo del sistema desde otras tecnologías Front End. El dominio en POCO (Plain Old CLR Objects), con lo que no usaría LINQ2Sql o Entity Framework en principio (sé que hay soporte para POCO en EF, pero es un Work In Progress, no quisiera sumar más complejidad a algo que ya es complejo). Podría usar un ORM, pero quiero explorar el camino de ORM por código propio: escribir el mapeo generando código automático para las entidades que vayan surgiendo, con manejo de Lazy Load, y Cache… Pero son ideas técnicas. Lo importante es comenzar con algo, que vaya tomando forma.

Primer candidato a sistema a implementar: un sistema de turnos.

Nos leemos!

Angel "Java" Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez
http://www.msmvps.com/lopez
http://ajlopez.wordpress.com
http://ajlopez.zoomblog.com

Posted Thu, Jan 14 2010 13:05 by lopez | 4 comment(s)

AjClipper: un intérprete como Clipper que usa .NET

Pueden encontrar el código de un intérprete que sigue una sintaxis similar a Clipper (hace un tiempo escribí Remember Clipper (en Anglish, Angel's English) Recordando a Clipper ahí hay más enlaces sobre el lenguaje). Es de código abierto, y está albergado en mi proyecto de Code Katas en Goggle code:

http://code.google.com/p/ajcodekatas/source/browse/#svn/trunk/AjClipper

Es un intérprete, escrito en C#, y como otros que escribo, tiene acceso a los objetos nativos de .NET. Pienso que todo intérprete debería aprovechar la librería de clases que tenga el framework que lo soporta (que puede ser .NET o Java). Escribí el intérprete para:

- Practicar TDD (Test-Driven Development)
- Crear una herramienta simple para apalancar el conocimiento de Clipper de uno de los equipos en los que participo, para que practiquen algo más de .NET

Debería escribir posts sobre la implementación interna, visibilidad de variables, comandos, acceso a objetos .NET, manejo de work areas, etc… Una idea que estoy explorando es ejecutar el intérprete desde una páginas ASP.NET:

 

(Hay una aplicación web en el proyecto con una única página de prueba para ejecutar un texto que se ingresa).

Mi colección de enlaces sobre Clipper:

http://delicious.com/ajlopez/clipper

Debería mejorar el acceso a base de datos, y completar el lenguaje con más comandos y características.

Nos leemos!

Angel “Java” Lopez
http://www.ajlopez.com
http://www.msmvps.com/lopez
http://ajlopez.wordpress.com
http://ajlopez.zoomblog.com
http://twitter.com/ajlopez

Posted Thu, Jan 14 2010 8:10 by lopez | with no comments

ALT.NET Hispano VAN (reunión virtual): FitNesse + Acceptance Testing + Selenium

El próximo sábado 16 de Enero, tendremos nueva VAN a las 18 GMT, 3 de la tarda acá en Buenos Aires, organizada por la comunidad ALT.NET Hispano. El presentador del tema, Diego Jancic, explica:

Para los interesados, les comento que la idea es hablar en torno a FitNesse y Acceptance Testing, y que la conversacion guie los detalles y los intereses, para profundizar sobre cualquier tema; basicamente es mantener el espiritu Agile de reuniones.
De cualquier forma, estoy preparando todo como para que haya una base de temas interesante para guiar la VAN.
Resumen:
La herramienta FitNesse, incluyendo todo lo necesario para comenzar y llegar a integrarla con .NET. Adicionalmente, se incluiran otros 2 temas que son claves para aprovechar FitNesse al maximo. Primero, será indispensable hablar de Acceptance Testing, para entender su importancia y utilidad en el desarrollo de software; y luego, Selenium, una herramienta que permite probar aplicaciones web. Ésta ultima será simplemente un ejemplo de aplicacion, ya que FitNesse no esta limitado a aplicaciones Web, cualquier tipo de extension y aplicacion esta permitida.
Objetivo:
Permtir a cualquier persona con conocimientos de programacion, configurar un ambiente de pruebas automatizadas y orientadas al cliente. De forma que alguien sin conocimientos de sistemas, pueda integrarse rapidamente a un ambiente de desarrollo, definiendo pruebas de cualquier tipo.
Indice de Temas (tentativo):
* Acceptance Testing: Breve introduccion.
* Selenium IDE: Introduccion, demo y problemas.
* FitNesse
** FitNesse en solitario: Instalacion, introduccion, arquitectura, formato de la Wiki, ejemplos incluidos
** Extensibilidad con .net
** Integracion con Selenium RC
* Versionado de las pruebas
* Integracion de FitNesse con NAnt y CruiseControl.NET

Pueden leer más sobre los temas en:

http://www.fitnesse.org/
http://seleniumhq.org/
http://en.wikipedia.org/wiki/Selenium_(software)
http://seleniumhq.org/projects/ide/
http://en.wikipedia.org/wiki/Acceptance_testing
http://www.extremeprogramming.org/rules/functionaltests.html
http://www.extremeprogramming.org/rules/userstories.html

Más información sobre cómo asistir a la reunión virtual, software necesario, enlaces: http://altnet-hispano.pbworks.com/Descripcion-de-Reuniones

Nos leemos!

Angel “Java” Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez

Posted Tue, Jan 12 2010 10:44 by lopez | with no comments

Refactoreando AjLisp: un intérprete Lisp escrito en C#

En estos días estuve reimplementando el núcleo de mi intérprete Lisp de código abierto AjLisp. Había escrito sobre la anterior versión en el 2008:

AjLisp: a Lisp interpreter in .NET
AjLisp: un intérprete Lisp en .NET

Es trabajo en progreso. Pueden bajar el código de:

http://code.google.com/p/ajlisp/source/browse/#svn/trunk/AjLisp

(hay otras dos implementaciones en ese repositorio, en desarrollo: AjScheme, un Lisp tipo Scheme, y AjSharpure, que intenta seguir las ideas de Clojure). Debería escribir sobre esas implementaciones. Este post es el inicial en una serie sobre AjLisp. Es una corta introducción al estado actual del proyecto.

El principal cambio en esta nueva versión: el intérprete puede manejar objetos y valores nativos. La alternativa hubiera sido apuntar a esos objetos a través de “wrappers”, alguna clase que implemente SymbolicExpression o similar. Pero elegí manejar directamente objetos nativos. Para eso, cambié las primitivas y clases relacionadas para que recibieran como argumentos objetos en vez de IExpression. Sigue habiendo una interfaz IExpression, defined como:

    public interface IExpression
    {
        object Evaluate(ValueEnvironment environment);
    }

El ValueEnvironment (planeo cambiarle el nombre a BindingEnvironment, y derivarlo de alguna interfaz tipo IBindingEnvironment) mantiene una asociación anidada de nombres y valores:

Hay un interfaz IFunction:

    public interface IFunction
    {
        object Apply(List arguments, ValueEnvironment environment);
    }

que debería ser implementada por cualquier form expression (la cabeza de una lista a evaluar).

Las dos clases principales que representan los tipos núcleo del AjLisp son identificadores y listas:

Todo el proyecto fue armado siguiendo Test-Driven Development, así que no tuve problemas en cambiar la versión anterior: tenía toda una batería de tests que me ayudó en el proceso de refactoring. Este es el estado actual de los test:

Debería escribir sobre:

- La implementación de ValueEnvironment
- Manejo de objetos nativos
- El tipo List y su evaluación
- Evaluación de Identifier
- Las primitivas implementadas
- El Lexer y el Parser
- Operaciones numéricas
- Números racionales (AjLisp puede manejar pares enteros numerador/denominador)

Ahora, luego de lo que aprendí desarrollando estos proyectos (AjLisp, AjScheme, AjSharpure), estoy escribiendo un núcleo mínimo AjCoreLisp, para mostrar cuáles son las primitivas mínimas para crear un intérprete Lisp. Armado con esa implementación, me gustaría explorar alternativas de compilación, en vez de ser sólo intérprete. Mi primer candidato es Dynamic Language Runtime. Otro podría ser la producción de código C# directo. Sería demasiado encarar esa exploración sobre un intérprete “más grande”. Primero, entonces, estudiaré sobre compilar un intérprete con menos primitivas, más condensado.

Nos leemos!

Angel “Java” Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez

Posted Sun, Jan 10 2010 11:50 by lopez | with no comments

Tales from the Scrum: Estimación Agil por Mike Cohn

Una de las preguntas más frecuentes de los asistentes a mis charlas de Scrum, es ¿cómo se estima en un proyecto de Scrum o ágil? Hace unos meses, encontré estos videos. Quiero hoy compartirlos con Uds.  Mike Cohn es un reconocido experto en el mundo Agile y Scrum. Pueden visitar su blog donde publica posts sobre temas que nos podemos encontrar en un proyecto Scrum.

En estos dos videos, él explica claramente que significa estimación en un proyecto ágil (involucrando al equipo en la estimación, haciendo iteraciones, planning poker, todas las prácticas de Scrum …):

Alta resolución: http://www.youtube.com/watch?v=jeT0pOVg0EI

Alta resolución: http://www.youtube.com/watch?v=jeT0pOVg0EI

Los videos fueron tomados el 20 de Marzo del 2007, en la Bay XP Meeting.

Espero ir comentando en español los principales puntos que expone Mike Cohn, en futuros posts de esta serie.

Nos leemos!

Angel “Java” Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez

Posted Fri, Jan 8 2010 10:01 by lopez | 1 comment(s)

La familia AjLisp: implementado intérpretes Lisp en C#

En los últimos meses, estuve activo escribiendo intérpretes Lisp. Desde los ochenta, me gusta escribir ese tipo de intérpretes. Uno de mis ejercicios preferidos cuando estudio un nuevo lenguaje de programación, es escribir un intérprete Lisp en ese lenguaje (otro ejercicio es escribir un intérprete del lenguaje en estudio).

En el 2008, publiqué un código escrito en C#, AjLisp:

AjLisp: a Lisp interpreter in .NET
AjLisp: un intérprete Lisp en .NET

A la mitad del 2009, comencé a investigar Clojure. Dedicí explorar las nuevas ideas de ese lenguaje, reinplementánlo en C# (el Clojure original está escrito en Java, pero hay una versión en .NET, que compila usando DLR, Dynamic Language Runtime). Clojure compila a bytecodes Java. Mi versión es sólo un intérprete (debería estudiar y aprender sobre DLR o compilación .NET, y sobre cómo pasar el árbol de mi intérprete a código compilado). El resultado de todo esto es “work in progress”, se llama AjSharpure (se llamaba AjClojure, pero tuve que cambiar el nombre). Pueden ver el código, en desarrollo, en:

http://code.google.com/p/ajlisp/source/browse/#svn/trunk/AjSharpure

Inicialmente, mi idea era portar “uno a uno” el código de Java del Clojure original, pero me dí cuenta al tiempo que su código base no es fácilmente leíble, no tiene test en código, ninguna especificación acerca de la conducta esperada de docenas de clases y centeneares de métodos. Así que paré el desarrollo, y repensé el camino a seguir. Tomé coraje, olvidé el código inicial, y comencé de nuevo, de abajo hacia arriba, usando a fondo Test-Driven Development (TDD), implementando pieza por pieza, para ir consiguiendo parte por parte la conducta esperada externa del lenguaje, en vez de seguir de cerca su implementación interna.

Ahora está algo tranquilo el desarrollo de AjSharpure, porque estoy estudiando formas de implementar lo que me falta, como variables, Shared Transactional Memory, y otros temas, como References. Mientras, volví a mi versión 2008 de AjLisp. Escribí una nueva versión en 2009, haciendo un refactoring importante, armado de lo que había aprendido con AjSharpure. Ahora, tiene acceso y manejo de objetos y valores nativos. El trunk está en:

http://code.google.com/p/ajlisp/source/browse/#svn/trunk/AjLisp

No hay un Lisp “base”, y hay DOS principales dialectos: Common Lisp y Scheme. No me gustan algunas cosas de Common Lisp (debería escribir un post sobre mi razones), así, que para conocer más sobre Clojure y otros Lisp actuales, comencé a escribir AjScheme, un intérprete que implementa mucho de lo que es la referencia de Scheme (renuncié a implementar definición de macros como en el Scheme original, uso mis más conocidas mlambdas y expansión de macros):

http://code.google.com/p/ajlisp/source/browse/#svn/trunk/AjScheme

El AjLisp nació siguiendo un viejo libro de Christian Queinnec (un libro de los ochenta, no uno de sus más nuevos). No pude encontrar el código del libro en la web. Queinnec incluía en el texto el código de un intérprete Lisp escrito en su propio Lisp. No tengo el libro acá (lo tengo en mi segundo cubil). Me puse a investigar sobre lo mínimo que necesita ser implementado en un Lisp básico. Así que estos días estoy trabajando en el AjCoreLisp:

http://code.google.com/p/ajlisp/source/browse/#svn/trunk/AjCoreLisp

No tiene parser ni lexer. La idea es implementar un intérprete mínimo usando AjCoreLisp como la base: el resultado es MinimaLisp, y está incluido en ese trunk. Estoy implementando las mínimas primitvas, y estoy tratando de escribir el resto de las forms más comunes como funciones o macros. Una decisión “geek” ;-) : implementar la expasión de macros con backspace escribiéndola como una macro! El resultado en:

http://pastie.org/765371

Una vez que tenga AjCoreLisp/MinimaLisp estabilizado, haré refactor de AjLisp, AjScheme, para usar el kernel más pulido, pero agregaré como primitivas las forms más usadas. Debería medir el impacto de implementar forms más usadas como macros, en lugar de primitivas. Tengo confianza en poder hacer todos esos cambios, porque todo lo escrito está vigilado por una batería de tests (el haber seguido TDD y tener tests me ha salvado el día muchas veces, cuando he refactorizado mucho del código base).

Como próxima misión: escribir posts sobre estos diferentes intérpretes, variaciones sobre un leit-motiv: las hermosas ideas del lenguaje Lisp.

Para los que quieran estudiar más sobre Lisp, mis enlaces sobre el tema:

http://delicious.com/ajlopez/lisp
http://delicious.com/ajlopez/scheme
http://delicious.com/ajlopez/clojure
http://delicious.com/ajlopez/commonlisp

Nos leemos!

Angel “Java” Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez

Posted Tue, Jan 5 2010 10:15 by lopez | 1 comment(s)

GoRoutines y Canales en C#

En post anteriores:

Canales y GoRoutines en AjSharp (Part 1)
Canales y GoRoutines en AjSharp (Part 2)

describí la implementación de gorutinas (goroutines, como en el lenguaje Go de Google), y canales en mi intérprete AjSharp. Al final del año que pasó, escribí una prueba rápida, implementando los mismos conceptos, pero para ser consumidos esta vez desde C# directamente. Pueden ver el código en

http://code.google.com/p/ajcodekatas/source/browse/#svn/trunk/AjConcurr

Primero, porté la clase Channel:

public class Channel
{
    private AutoResetEvent sethandle = new AutoResetEvent(false);
    private AutoResetEvent gethandle = new AutoResetEvent(false);
    private object value;

    public void Send(object value)
    {
        this.gethandle.WaitOne();
        this.value = value;
        this.sethandle.Set();
    }

    public object Receive()
    {
        this.gethandle.Set();
        this.sethandle.WaitOne();
        object result = this.value;
        return result;
    }
}

El código tiene una clase estática GoRoutines, con métodos como:

public static void Go(Action action)
{
    Thread thread = new Thread(new ParameterizedThreadStart(GoRoutines.RunAction));
    thread.IsBackground = true;
    thread.Start(action);
    //ThreadPool.QueueUserWorkItem(new WaitCallback(RunAction), action);
}

public static void Go(ITask task)
{
    Thread thread = new Thread(new ParameterizedThreadStart(GoRoutines.RunTask));
    thread.IsBackground = true;
    thread.Start(task);
    //ThreadPool.QueueUserWorkItem(new WaitCallback(RunTask), task);
}

Pueden lanzar una Action (lo que es en el framework delegate System.Action<>), en un nuevo thread (traté de hacerlo poniendo la tarea en la cola de ThreadPool, pero, no sé por qué, el rendimiento pasó a ser muy bajo; mi intento quedó en comentarios del código de arriba).

Cuando una acción recibe parámetros, se encapsulan los dos en una Task<>, como esta que recibe dos parámetros:

public class Task<T1, T2> : ITask
{
    private Action<T1, T2> action;
    private T1 parameter1;
    private T2 parameter2;

    public Task(Action<T1, T2> action, T1 parameter1, T2 parameter2)
    {
        this.action = action;
        this.parameter1 = parameter1;
        this.parameter2 = parameter2;
    }

    public void Run()
    {
        this.action(this.parameter1, this.parameter2);
    }
}

(hay clases Task para uno, dos o tres parámetros).

Pueden invocar GoRoutines.Go directamente, especificando una acción y sus parámetros:

public static void Go<T1, T2>(Action<T1, T2> action, T1 parameter1, T2 parameter2)
{
    Go(new Task<T1, T2>(action, parameter1, parameter2));
}

Podemos escribir esta invocación usando expresiones lambda:

[TestMethod]
public void RunGoRoutineWithTwoParameters()
{
    int i = 0;
    AutoResetEvent handle = new AutoResetEvent(false);
    GoRoutines.Go((x, y) => { i = x + y; handle.Set(); }, 2, 3);
    handle.WaitOne();
    Assert.AreEqual(5, i);
}

Con todo esto implementado, escribí una aplicación de consola  AjConcurr.Primes, reimplementando el ejemplo de números primos de mi anterior post:

Channel numbers = new Channel();
GoRoutines.Go(() => { for (int k = 2; ; k++) numbers.Send(k);  });
Channel channel = numbers;
int prime = 0;
while (prime < 1000)
{
    prime = (int)channel.Receive();
    Console.WriteLine(prime);
    Channel newchannel = new Channel();
    GoRoutines.Go((input, output, p) =>
    {
       while (true)
       {
           int number = (int)input.Receive();
           if ((number % p) != 0)
               output.Send(number);
       }
    }, channel, newchannel, prime);
    channel = newchannel;
}

Me gusta ver este código formateado en pastie:

http://pastie.org/761916

Próximos pasos:

- Mejorar Channel para soportar múltiples productores y consumidores de valores que operan de forma simultánea sobre el mismo canal.
- Agregar soporte de Futures
- Agregar características de reactive programming (sé que está el Reactive Framework, quería experimentar algo con código propio).

Nos leemos!

Angel “Java” Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez

Posted Sun, Jan 3 2010 10:44 by lopez | 1 comment(s)

Filed under: , ,