Angel "Java" Lopez : Lenguajes de Programación

Segunda Nerddinner en Buenos Aires

lopez — Wed, 28 Oct 2009 15:44:44 GMT

Hace un par de meses ya tuvimos la primer nerddinner de Buenos Aires, ahora se viene la segunda!

Pueden ver los detalles en:

http://www.nerddinner.com/1236

Pueden inscribirse ahí, o contactar a los organizadores @PabloZaiden @Rodolfof por Twitter. Es el jueves 5 de Noviembre, 21 horas, se espera cerveza y pizza, y conversaciones nerd a full!

La anterior (y primera en Buenos Aires) se desarrolló en http://www.lamaie.com.ar (donde suelo comer empanadas que corto con cuchillo), buen lugar, cervezas, y pizzas. Asistieron una veintena de nerds locales, y hubo interesantes discusiones, de todo tipo, desde multitouch hasta “mi mac enciende más rapido que tu Windows 7”. Nerd a full… :-)… Por ejemplo, el bueno de @Rodolfof me explicó su trabajo en el “metadata framework” que estuvieron implementando en Lagash,

La segunda será en la pizzería San Carlos, en Rivadavia 4548:

Según el bueno de @Rodolfof ahí se reunía la gente de FidoNet en los 90. Yo no iba a esas reuniones. Pero recuerdo la pizzería (y café) de la época de principios de los 80. Iba a desayunar ahí, cuando llegaba de Quilmes, a trabajar en un cliente que vendía máquinas y sistemas (en aquel entonces, se vendía todo junto). Tenía que programar con Ohio Scientific, computadoras Ontel, alguna Cromenco, bueno… éramos tan pobres… :-)

Siempre pueden organizar una nerddinner en su ciudad, Uds. mismos, visitar la portada del sitio:

http://www.nerddinner.com

Ven ahí las que están siendo planeadas para los próximos días, en todo el mundo:

La aplicación que soporta al sitio está hecha con ASP.NET MVC, y está publicado el código en:

http://nerddinner.codeplex.com/

Para entender cómo lo fueron haciendo en ASP.NET MVC, se pueden bajar un .pdf desde http://tinyurl.com/aspnetmvc. Pueden probar de ejecutarlo en Mono, leer: http://www.jprl.com/Blog/archive/development/mono/2009/May-14.html

Nos leemos!

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

VAN sobre Boo con Rodolfo Finochietti

lopez — Fri, 23 Oct 2009 09:22:26 GMT

Vuelven las VAN (Reuniones Virtuales) de ALT.NET Hispano. La próxima, es este sábado 24 de Octubre, a las 18:00 GMT/UTC (Greenwich) (En Buenos Aires, con GMT-3, serían las 3 de la tarde). El tema será, principalmente, el lenguaje Boo, a cargo del bueno de Rodolfo Finochietti (@rodofof).

Pueden ver detalles en

VAN sobre Boo con Rodolfo Finochietti, Sábado 24 de Octubre

Será en parte, continuación de la anterior

Alt.NET Hispano- VAN con Martín Salías y lenguajes en .NET

Pueden ver el video resultado de esa anterior reunión en:

Virtual ALT.NET sobre Lenguajes

Son todos temas como los que tratamos en algún TechNight de Buenos Aires, el año pasado: lenguajes de programación e implementaciones en .NET (ahí dejé bastantes enlaces sobre los temas que ahora están siendo actualizados en esta serie de VANs).

Según adelanta Rodolfo, el tema será:

Básicamente mi exposición se va a centrar en porque me gusta Boo. Todos los lenguajes estáticos en .NET son bastante similares (con el DLR esto cambio un poco), y esto creo yo tiene una razón que voy a explicar en el charla. En cambio Boo no se parece un lenguaje .NET. Su diseñador (Rodrigo De Oliveira) lo creo como un herramientas que le facilita la construcción de aplicaciones.

Resumiendo: Voy a hacer una intro al diseño de lenguajes estáticos en .NET y después me voy a centrar en Boo y sus características.

Recuerden:

Si no conocen qué es una reunión VAN, pueden consultar VAN meetings. Para ver cómo se desarrolla una VAN de ALT.NET Hispano, y qué software necesitan para asistir, ver Descripcion-de-Reuniones-VAN. Pueden ver el historial de anteriores reuniones VAN (visiten las que dieron, por ejemplo, sobre NHibernate, WPF y demás) (yo ya participé en VAN sobre Scrum y en otra sobre generación de código, que quedará publicada en estos días). Supongo (pero confirmen) que la URL de entrada de la VAN de Martín será http://snipr.com/virtualaltnet. Cualquier cosa, pueden consultar la lista de correo de ALT.NET Hispano. También pueden suscribirse para proponer nuevos temas, y colaborar con la comunidad.

Visiten el sitio de Boo si quieren averiguar más sobre el lenguaje, y lean el Boo Manifesto. Tomé la imagen del blog http://blogs.codehaus.org/people/bamboo/archives/boo.html.

Nos leemos!

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

Alt.NET Hispano: VAN con Martín Salías y lenguajes en .NET

lopez — Thu, 01 Oct 2009 09:32:57 GMT

Este viernes, 2 de Octubre, la comunidad de Alt.NET Hispano preparar una VAN (desconferencia, reunión virtual), a las 5:00pm GMT (2 de la tarde acá en Buenos Aires), sobre lenguajes en .NET, con el bueno de Martín Salías (@MartinSalias). Pueden ver más detalle en:

Por primera vez tendremos VAN entre semana con Martín Salías

Explica ahí Martín:

mi idea es charlar un poco entre todos sobre el florecimiento de los lenguajes en entornos manejados. Me parece que no es coincidencia que en el ambiente Java esté pasando algo similar a lo que tenemos en .NET.

Lenguajes Dinámicos:
JVM: Jython, JRuby, Groovy
.NET: IronPython, IronRuby

Lenguajes funcionales:
JVM: Scala, Clojure
.NET: F#, C# (¡cada vez más!)

Otros:
Ioke (JVM/.NET), Boo (.NET)

…

Me parece interesante repasar juntos los objetivos y desarrollo histórico del CLR, el DLR, y cómo impactó en esta nueva tanda de lenguajes la influencia del ambiente Open Source, que es tan cercano al espíritu Alt.NET.

El bueno de Martín, menciona algunos proyectos míos de lenguajes… snif… me van a hacer llorar de la emoción… snif… :-)

Si no conocen qué es una reunión VAN, pueden consultar VAN meetings. Para ver cómo se desarrolla una VAN de ALT.NET Hispano, y qué software necesitan para asistir, ver Descripcion-de-Reuniones-VAN. Pueden ver el historial de anteriores reuniones VAN (visiten las que dieron, por ejemplo, sobre NHibernate, WPF y demás) (yo ya participé en VAN sobre Scrum y en otra sobre generación de código, que quedará publicada en estos días). Supongo (pero confirmen) que la URL de entrada de la VAN de Martín será http://snipr.com/virtualaltnet. Cualquier cosa, pueden consultar la lista de correo de ALT.NET Hispano. También pueden suscribirse para proponer nuevos temas, y colaborar con la comunidad.

El año pasado con Rodolfo Finochietti (@rodofof) y Martín, dimos un Technight en las oficinas de Microsoft Argentina (Buenos Aires), sobre lenguajes de programación e implementaciones en .NET. (Lean el material de Rodolfo sobre C# 4.0). Me pareció muy interesante esa charla, y me divertí mucho preparándola y compartiéndola con Martín y Rodolfo. Creo que deberíamos invitar a Rodolfo para que siga con una próxima VAN completando el tema que inicia Martín.

Post relacionados:

Javascript, la programación del futuro
Babel de lenguajes en .NET
Papas fritas, cervezas y una babel de esos raros lenguajes nuevos

(Me gustó tanto la pintura de la Torre de Babel, aludiendo a múltiples lenguajes, que usé en otro post, que la vuelvo a usar acá, con mi propio permiso… :-)

Como es hábito, colecciono enlaces sobre estos temas en:

Bueno, como siempre, los enlaces de estos temas, que colecciono, desde:

Nos leemos!

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

Explorando objetos con Smalltalk

lopez — Thu, 24 Sep 2009 09:33:50 GMT

Estoy siguiendo a @jarober (James A. Robertson) en Twitter. El es el Cincom Smalltalk Product Evangelist. Postea enlaces, recursos y novedades sobre Smalltalk, en particular sobre los productos Cincom. Escribe un blog:

http://www.cincomsmalltalk.com/blog/View.ssp

que corre sobre Smalltalk. Si visitan ese blog, encontrarán varios posts con videas sobre Smalltalk. Hace poco, Robertson publicó:

Smalltalk Daily: Exploring Objects

Este es el video:

(Please visit the site to view this media)

Robertson escribe:

Many times, you want to do something, know that it can be done - but just aren't sure how to construct the code to do it. If you have an object, you can usually solve that problem by drilling into it with the inspector and looking at it. Today we learn how to programmatically change workspace page text by drilling into a workspace.

Es refrescante ver este tipo de interacción con objetos, tan “a la Smalltalk”.

Debo reanudar mi trabajo en mi Smalltalk VM (intérprete) AjTalk, pueden leer

AjTalk, un intérprete tipo Smalltalk

Le tendría que agregar soporte visual. Mi idea, como en otros intérpretes que estoy escribiendo, es interactuar con el framework de base, en este caso, .NET con su CLR. De esta forma, puedo sacar provecho de todo lo que está armado en ese framework. En estos días, todo lenguaje debería tomar ventaja de un framework de clases ya armado: .NET y Java son las opciones obvias a tomar (ver Clojure como un ejemplo “moderno” de esta estrategia) (o AjSharp… :-)

Nos leemos!

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

AjSharp: un lenguaje dinámico en C#

lopez — Tue, 22 Sep 2009 10:04:06 GMT

Durante el desarrollo de AjGenesis, mi proyecto de generación de código, definí y usé un lenguaje interpretado, llamdado AjBasic, que me dió libertad para implementar tareas, plantillas y acceso a .NET, de una forma muy flexible. El año pasado comencé a separar la implementación de AjBasic del núcleo de AjGenesis, para poder irlo mejorando. Escribí el núcleo de un intérprete, AjInterpreter, y como prueba de concepto, construí sobre él a AjBasic, y a otro lenguaje AjSharp, con una sintaxis más tipo C#. Más információn en:

AjSharp- a C Sharp-like interpreter, work in progress
AjSharp – un intérprete a la C# trabajo en progreso

Ahora, este año, lo reescribí en una implementación nueva, dentro de mi AjCodeKatas Google Code. El núcleo del intérprete es ahora AjLanguage, y AjSharp es el lenguaje con un parser que se apoya en la “virtual machine” que da el AjLanguage, para armar y ejecutar un árbol de comandos y expresiones:

Pueden ver el código en desarrollo y bajarlo desde:

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

Variables, expresiones y comandos

Las variables no son tipadas, y son automáticamente declaradas cuando son usadas:

a = 1;

b = 2;

Estas variables contienen valores enteros, pero pueden asignarles valores de otros tipos en cualquier momento:

a = “one”;

b = “two”;

Los comandos habituales son soportados:

if (k>0)

   return;

for (k=1; k<=10; k++)

   sum = k+sum;

while (j<10)

   DoProcess(j);

foreach (element in elements)

   AddElement(element);

Las condiciones puede ser cualquier expresión, no solamente una que de resultado booleano. Ver más adelante, la explicación sobre el valor False.

Funciones y rutinas

Esta es la sintaxies para escribir una función factorial.

function Factorial(n)

    if (n<=1)

        return 1;

    return n * Factorial(n-1);

La palabra sub puede ser usada para definir subrutinas.

Funciones y subrutinas son como cualquier otrosvalores. Puede ser definidos sin nombre y asignados a variables:

Add1 = function (n) { return n+1; }

two = Add1(1);

function Apply(func,values)

    list = new List();

    foreach (value in values)

        list.Add(func(value));

    return list;

numbers = new List();

numbers.Add(1);

numbers.Add(2);

numbers.Add(3);

function Square(n) { return n*n; }

squared = Apply(Square, numbers);

squared2 = Apply(function (n) { return n*n; }, numbers);

Manejo de objetos .NET nativos

Uno de los objetivos de diseño de AjLanguage es que pudiera acceder a objetos .NET. Pueden ser creados con la palabra new:

ds = new System.Data.DataSet();

dinfo = new System.IO.DirectoryInfo(“.”);

foreach (fi in dinfo.GetFiles()) {

    PrintLine(fi.FullName);

Objetos dynámicos

Pueden ser creados usando la palabra new. Un objeto dinámico acepta nuevos miembros (variables y métodos):

dynobj = new DynamicObject();

dynobj.FirstName = “Adam”;

dynobj.LastName = "Genesis”;

dynobj.Age = 800;

dynobj.FullName = function() { return FirstName + “ “ + LastName; }

Otra notación:

dynobj = new { Name = “Adam”, Age = 800 };

Otra notación:

dynobj = new { var FirstName = “Adam”; var LastName = “Genesis”;

 function FullName() { return FirstName + “ “ + LastName; }

Los objetos dinámicos se definen automáticamente, poniendo valores en sus propiedades:

Project.Database.Provider = “…”;

Project.Database.ConnectionString = “…”;

crea el objeto dinámico Project, con una propiedada Database que es a su vez otro objeto dinámico. Ese código equivale a:

Project = new DynamicObject();

Project.Database = new DynamicObject();

Project.Database.Provider = “…”;

Project.Database.ConnectionString = “…”;

Un experimento (veré si queda en la implementación final) las litas se definen automáticamente usando el método Add:

Project.Entities.Add(new { Name = “Customer”, Table = “dbo.Customers” });

equivale a:

Project = new DynamicObject();

Project.Entities = new List();

Project.Entities.Add(new { Name = “Customer”, Table = “dbo.Customers” });

Clases dinámicas

Una clase puede ser definida usando esta sintaxis:

class Person {

    var FirstName;

    var LastName;

    var Age;

    function FullName() {

        return FirstName + “ “ +

            LastName;

Una nueva instancia puede ser creada como siempre:

adam = new Person() { FirstName = “Adam”, LastName = “Genesis”, Age = 800 };

La instancia, a su vez, es dinámica: nuevos miembros pueder serle adosados, y pueden agregar o redefinir métodos:

adam.FullName = function() { return “The “ + FirstName; };

Pueden crear una clase como un valor:

Person = new DynamicClass();

pero todavía tengo que definir bien la interfaz para agregar miembros de instancia.

Clases ya definidas

Hay algunas clases predefinidas:

dynobj = new DynamicObject();

list = new List(); // implementing IList

dict= new Dictionary(); // implementing IDictionary

Funciones primitivas

Hay unas pocas funciones y subrutinas definidas:

Print(“Hello”);

PrintLine(“Hello World”);

Hay tres funciones predefenidas para ejecutar y evaluar código dinámicamente:

Include("program.ajs");

Evaluate("k+1");

Execute("k=1;");

Include ejecuta los comandos dentro de un archivo. Evalue analiza y evalúa una expresión. Execute compila y ejecuta comandos.

El valor false

Cualquier valor que sea false, null, 0 o el string vacío, será evaluado como falso dentro de una expresión condicional:

if (k)

    PrintLine(“true”);

else

    PrintLine(“false”);

El ejemplo de arriba imprime “false” en ejecución, si k es zero o indefinida. Si una variable es indefinida, cualquier acceso a sus miembros (que no sean métodos) retorna null, no una exception:

if (Project.Database.ConnectionString)

    PrintLine(“true”);

else

    PrintLine(“false”);

Este comando imprime de nuevo “false”, si la variable Project está indefinida.

Arreglos, listas y diccionarios

Vectores nativos puede ser definidos, usando una longitud:

firstprimes = new int[10];

o con valores:

firstprimes = new int[] { 1, 2, 3, 5, 7, 9 };

Una lista es creada dinámicamente si comenzamos a asignar valores con subíndices consecutivos, desde 0, a una variable no definida aún:

numbers[0] = “zero”;

numbers[1] = “one”;

numbers[2] = “two”;

numbers[3] = “three”;

Un diccionario es automáticamente creado si los subíndices no son numéricos:

numbers[“one”] = 1;

numbers[“two”] = 2;

numbers[“three”] = 3;

Si necesitan más características, siempre pueden usar el framework .NET nativo.

Interfaz de consola

El proyecto AjSharp.Console es una aplicación de consola, donde pueden ingresar y ejecutar comandos AjSharp (no expresiones):

No hay comando para salir, todavía. Simplemente, Control+C en Windows (no lo probé, pero todo el código debería ser recompilable en Mono).

Próximos pasos

Hay varias cosas que quisiera agregar. Una lista parcial:

- Implementar AjBasic como otro lenguaje que use AjLanguage
- Soporte de Generics
- Soporte de plantillas/templates (como en AjGenesis)
- Integrar a la generación de código de AjGenesis
- Compilar el AST a Dynamic Language Runtime (DLR)

Nos leemos!

Angel “Java” Lopez

http://www.ajlopez.com
http://twitter.com/ajlopez

Enlaces y noticias IV

lopez — Sun, 19 Jul 2009 13:51:36 GMT

Sigo con la costumbre coleccionar enlaces, de distintos temas. Los que me llamaron la atención:

PHP

Es el lenguaje más usado para el desarrollo de sitios dinámicos en la web. Tiene la simplicidad necesaria, y también el soporte de clases, librerías, acceso a base de datos como para hacerlo más poderoso. Tal vez se ha quedado en el desarrollo web, perdiendo en el terreno de programas de consola, servicios, o de ventanas. Hay montañas de código de ejemplo para estudiar y aprender. Algunos enlaces:

PHP programming tips and tricks Code Purity
Scripts Directory of PHP, ASP, ASP.NET, Java, Javascript, Perl and more! – Scripts
43 Must Read PHP Articles and Resources Hi, I'm Grace Smith
How To Create Your Own Stats Program (JavaScript, AJAX, PHP) Noupe
25 Resources to Get You Started with PHP from Scratch - Nettuts+
15 Wonderfully Creative Uses for PHP

Hay cantidad de sitios manejadores de contenidos (CMS) pueden ver

10 New PHP Content Management Systems(CMS)

http://php.opensourcecms.com/

Para un rápido Altas, bajas y modicaciones ver AjaxCRUD.com - Use PHP & AJAX to CRUD from a mysql database (create / read / update / delete)

No creo que alguien pueda pasar fácilmente de PHP a ASP.NET pero pueden leer Move from PHP to ASP.NET

Tiene sus años, pero es interesante Understanding MVC in PHP - O'Reilly Media

Un armador de proyectos, a la Apache Ant, pero en PHP: Phing

Comenzando con Joomla Beginners - Joomla! Documentation

Veo implementando el Template Attribute Language en PHP: http://phptal.org/

DEBEN VER PHPCamp: learn something new everyday

Para perderse en enlaces, http://delicious.com/ajlopez/php

.NET

Para los que quieren ver manejadores de contenido (CMS) en ASP.NET:

http://aspx.opensourcecms.com/

El área de código abierto de .NET está bien activo: Open Source .NET projects

Para estudiar: Expert to Expert- Brian Beckman and Erik Meijer - Inside the .NET Reactive Framework (Rx) Going

Un ejemplo de referencia FabrikamShipping – Home con Geneva Framework, autenticación federada y tutti li fiocci.

Un camino a explorar: reemplazar ORM (Object Relational Mapping) en runtime por generación de código: .NET ORM, Object Relational Mapping for .NET Telerik

Librería para Twitter http://tweetsharp.com/

ASP.NET MVC 1.0 ejecutando en Mono shaml-architecture - Google Code Basado en s#arp-architecture

Para mapear objetos http://automapper.codeplex.com/ (menos para el bueno de Rodolfo Finochietti que prefiere hacerse su propio mapeador :-)

Siempre es molesto el DataBinding a propiedades simples, habría que ver qué tal funciona http://www.codeproject.com/KB/cs/ObjectBindingSource.aspx (nested property binding)

Más de todo esto en http://delicious.com/ajlopez/dotnet

Generación de código

El proyecto Sculpture está muy bien armado, aunque focalizado en .NET http://sculpture.codeplex.com/ Es open source, se trasladó a la empresa:

http://www.dawliasoft.com/

Tienen una implementación de referencia: VotingManager.zip que partiendo de 55 líneas, consiguen generar una aplicación de 4111 líneas. Bueno, nada que el AjGenesis no pueda hacer… :-) … pero es más bonito.

Hibernate Class Generation Using hbm2java - O'Reilly Media Estoy reviendo esto, quiero comenzar a usar el tag <meta> para usar hibernate.cfg.xml y archivos .hbm.xml para alimentar como modelo a AjGenesis.

Para estudiar dos “approachs” Angle Bracket Percent - CodeDom vs T4- two approaches to Code Generation

Veo el editor de T4 T4 Editor - tangible T4 Editor plus UML tools

Desde AjGenesis puedo leer el archivo .dbml de Linq2Sql, que se puede generar desde la línea de comando con SqlMetal, tengo que estudiar Oleg Sych - » T4 Toolbox- LINQ to SQL classes generator

Yo tenía esta idea, pero la deseché por ser algo “convoluted”, pero es interesante: Using ASP.Net for Code Generation . En su tiempo, usé también PHP como lenguaje de generación, pero me gustó tener un lenguaje dedicado a generación con objetos dinámicos (AjBasic) con acceso a un framework de base (.NET por ahora), cosa que no tiene PHP en principio. Y en cuanto a usar ASP.NET, me obligaba a usar un lenguaje tipado .NET, que me resistía a hacerlo.

Siguiendo con T4, el lenguaje de templates de Visual Studio, a estudiar Angle Bracket Percent - The MVC T4 template is now up on CodePlex, and it does change your code

Parece interesante Sample Fluent NHibernate T4 Templates for Code Generation via LINQ To SQL

Steven Kelly siempre tiene algo interesante sobre DSM (Domain Specific Models) y generación de código. Comenta sobre Code Generation 2009 en Code Generation 2009 round-up

Para los que estén con el framework .NET de Lohtka, CSLA, pueden visitar el

CslaGenerator Google Groups

Ruby es un lenguaje que se presta a la generación de código, ver esto, de hace algunos años, pero a cargo del bueno Jack Herrington, autor de Code Generation in Action (alguien que vió la luz!!! :-) :

Como siempre, más información en http://delicious.com/ajlopez/codegeneration

Lenguajes de Programación

Descubriendo un clásico: Let's Build a Compiler

Un texto corto How does a an interpreter compiler work

Para estudiar Create a Language Compiler for the .NET Framework Using C# usa Reflection.Emit, bien a lo macho… :-)

Hay que escribir intérpretes y compiladores, “compiler generators are for sissies” :-), pero si quieren, pueden ver The Compiler Generator Coco/R

Más para ver Free Compiler Construction Tools- Lexers, Parser Generators, Optimizers (thefreecountry.com) y Basics of Compiler Design (pdf)

Para estudiar:

Michael Feathers on Programming Languages

Synrc Io Language CLR

Io (programming language) - Wikipedia, the free encyclopedia

InfoQ- The Ioke JVM Language- The power of Lisp and Ruby with an intuitive syntax

Ending the Era of Patronizing Language Design

Un volver a vivir:

History of the BASIC family of languages

Otro para el canal “Volver”, entorno de desarrollo xBase:

Xailer - El entorno de desarrollo definitivo en xbase

Free Pascal compilers and Pascal Programming - Freebyte's Guide to

Se acuerdan de MUMPS? MUMPS - Wikipedia, the free encyclopedia

Para leer APL, COBOL, & Dijkstra Paul Murphy ZDNet.com

Podría volver a estudiar: COBOL Programming Course, The COBOL Programming Language

Lista para buscar recursos Free Programming Tools, free compilers, free software components and

Excelente contenido Google Code University Programming Languages

Hay que ir viendo:

Clojure ver InfoQ- Rich Hickey on Clojure's Features and Implementation

Scala

Yo sigo trabajando en reimplementar las ideas de Clojure en C#, lo llamaba AjClojure, pero Rick Hickey (el creador de Clojure) me pidió que le cambiara el nombre (al fin tengo evidencia de que alguien lee mi Twitter!!! :-) Así, que en un rapto de imaginación, se llama AjSharpure. Pueden ir viendo mis avances en:

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

Más para ver sobre los lenguajes que me interesan en:
http://delicious.com/ajlopez/programminglanguages
http://delicious.com/ajlopez/smalltalk
http://delicious.com/ajlopez/logo
http://delicious.com/ajlopez/scala
http://delicious.com/ajlopez/lisp
http://delicious.com/ajlopez/forth
http://delicious.com/ajlopez/haskell
http://delicious.com/ajlopez/python
http://delicious.com/ajlopez/ruby
http://delicious.com/ajlopez/functionalprogramming
http://delicious.com/ajlopez/cobol

MVPs

El bueno de Rodolfo Finochietti fue nombrado Microsoft MVP por segundo año consecutivo. Felicitaciones @rodolfof! MVP for another year. También felicitaciones para el pibe Woloski, que renovó el nombramiento.

Nos leemos!

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

El mejor lenguaje, la mejor herramienta

lopez — Thu, 09 Jul 2009 15:17:36 GMT

Ayer escribía sobre la popularidad de los lenguajes de programación:

Justo ayer, también, @ebersys escribía en Twitter:

El bueno de Eber Irigoyen es miembro activo de Alt.NET hispano:

Vive en Salt Lake city, Utah, visiten su blog:

Que quieres desarrollar hoy?

Yo disiento con eso de “el mejor lenguaje es el que conoces mejor”. Mi contestación en Twitter fue:

Pero de donde puede venir eso de “el mejor lenguaje es el que conoces mejor”? Bueno, como comentaba ayer, hay grupos de lenguajes, y mucho de nosotros, estamos trabajando con .NET o Java o ambos. Son lenguajes de uso general, donde podemos hacer aplicaciones de consola, gráficas, o web. En los dos casos, más que lenguaje, tenemos un framework de clases, y entornos de desarrollo, desde Eclipse hasta Visual Studio. Creo que uno puede pensar que “el lenguaje que conoce es el mejor”, si está en uno de esos dos grupos: programando en Java o en .NET. Son más que lenguajes: son interminables clases y capacidades y plugins y wizards, que nos ayudan a hacer multitud de aplicaciones.

Pero sigo pensando que, si limitamos la pregunta a lenguajes, el mejor lenguaje es el que mejor se adecua a lo que tengo entre manos. Claro que con .NET o con Java, vamos a poder hacer más tipos diferentes de aplicaciones. Pero siempre es importante, si podemos elegir, considerar que hay lenguajes de todo tipo, con énfasis en distintos aspectos de la programación. Por ejemplo, en mi caso, en mi proyecto de generación de código AjGenesis, he elegido desde el principio, adoptar un lenguaje dinámico, no tipado, porque me parece lo más adecuado, flexible, adaptable, a lo que quería hacer (leer Generación de Código, AjGenesis y AjBasic). Y estoy muy contento con la elección.

Por otro lado, si vamos a hacer aplicaciones de empresa, nos baste .NET o Java, y en ese caso, elegiremos, si podemos, “el que conocemos mejor”.

Pero insisto: si vamos a .NET o Java, no vamos a “un lenguaje”, vamos a una tecnología, un framework de clases, y alguna IDE, vamos más allá de elegir un lenguaje. En este caso, destacaría la experiencia de desarrollo que nos dé la IDE que elijamos. En estos casos, tengo que comentar que tanto Eclipse como Visual Studio, son una gran ayuda a la hora del desarrollo. En mi opinión, Eclipse es demasiado “todo es un plugin”, cosa que en Visual Studio todo viene más armado y coordinado desde el principio. (Hace un tiempo que no veo NetBeans: cuando lo veía, me parecía que era mucha “bajada de línea” de Sun, donde se soportaba sólo lo que a Sun le importaba. Si le importaba JSF, desaparecía del mapa JSP y así.)

Entonces, uno podría pensar que la mejor herramienta es la IDE, el framework, la tecnología. Pero acá debo alzar la mano, y recordar una escena de Rambo II. Rambo sale de la cárcel, y vuelve a la selva, a rescatar a su antiguo jefe y entrenador, que ha sido capturado por el enemigo. En un campamento amigo, un agente especial le muestra un galpón, lleno de armas: orgulloso, le presenta a Rambo una tras otra arma, una más sofisticada y poderosa que la otra. Rambo no parece impresionarse, y pronuncia la frase, lapidaria: “La mejor arma es una mente despierta”.

Lo mismo digo: parafraseando a Rambo, “la mejor herramienta es una mente despierta”. No hay IDE, lenguaje, tecnología, plataforma, framework, que sustituya lo que tenemos entre las orejas. Si como desarrolladores no pensamos, no meditamos en lo que hacemos, por qué lo hacemos, qué necesitamos lograr, y solamente programamos de tal forma, porque está de moda, o está en los libros, o usamos tal framework, sin entenderlo cabalmente, sin ver cuál es el problema que resuelve, y lo vemos como una panacea o “silver bullit”, si en vez de pensar, digo, nos embarcamos ciegamente en el desarrollo, no hay IDE que nos ayude. Lo que Salamanca non da, natura non presta. Lo que no pensemos, no lo va a solucionar la IDE, ni el lenguaje.

Si uno piensa, puede llegar a ser productivo hasta en Assembler… :-)

Nos leemos!

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

Popularidad de Lenguajes de Programación

lopez — Wed, 08 Jul 2009 09:50:06 GMT

Me temo que AjLisp y AjBasic lo usamos yo y nadie más… snif… :-). Pero hay lenguajes más populares que esos. Ya es clásica la lista de TIOBE Software:

http://www.tiobe.com/index.php/content/paperinfo/tpci/index.html

donde aparece Java como el lenguaje más popular, lo que no me asombra. Pero sí me llama la atención la popularidad de C y C++, que deben tener su gran uso en el ambiente Unix, Linux, y otros. Como cuarto, encuentro hoy, Julio de 2009, a PHP, que lo entiendo: la mayor parte del código de sitios dinámicos está en PHP, lejos quedaron los años del predominio del venerable Perl. Y recién en sexto y séptimo lugar, está Visual Basic (parece que agrupan el de .NET y el clásico), y C#. Vean que al final de la lista, aparecen lenguajes con mínimos porcentajes, pero aparecen: RPG, Pascal, Abap, Lisp/Scheme. Más abajo, en la misma página encontraran la lista de posición 21 a 50, donde aparecen COBOL, Objective-C, Fortran, Logo, Prolog, Ada (todavía anda por ahí? :-), Scala, Erlang…. y esta es la lista de 51 a 100:

ABC, AD, Algol, Alpha, Applescript, Beta, Boo, C shell, cg, Clean, Cobra, cT, Curl, Dylan, Eiffel, Euphoria, Factor, Fan, Icon, IDL, Inform, Io, Lingo, MAD, Magic, Maple, Mathematica, MAX/MSP, MOO, MUMPS, Natural, Oberon, Occam, Oz, PL/I, Postscript, PowerBuilder, Progress, Q, R, Revolution, REXX, S-lang, SIGNAL, SPSS, SuperCollider, VBScript, Verilog, VHDL, XSLT

Notable lista, recomendaría tantos lenguajes de esa lista, simplemente para aprender nuevas formas de programar (notable que aparezca todavía MUMPS, REXX, tendría que ver con más detalle a Io). Esta lista de popularidad se basa en el examen de búsquedas en Google, hace un tiempo pasaron a agregar MSN y Yahoo.

Pero en estos días, encontré otra página:

http://langpop.com/

con información de ranking de popularidad, pero con agrupadas con distintas fuentes, como Yahoo Search, search en Google Code, Freshmeat, Craiglist, Amazon.

En lo que veo hoy ahí, julio de 2009, según Yahoo Search C es más popular que Java. Pero para Craiglist, primero PHP, segundo SQL (!!!), en Amazon ganan C, C++ y C#, por encima de Java. Y así, noto dispersión de los resultados, dependiendo de la fuente.

La popularidad de un lenguaje importa. No tanto para entender el lenguaje (muchos lenguajes “boutique” tienen interesantes conceptos, a estudiar con detalle), sino para tener una idea de qué tecnología ha sido adoptada por la comunidad, pero habría que ver más allá: por qué la eligieron, y en qué tipo de proyectos. Dudo que haya muchas aplicaciones desktop, en PHP.

Resumen: gran cantidad de lenguajes, hay lenguajes viejos, desde COBOL y Smalltalk, y más “nuevos” como Boo, Ruby, Python. Y `cuatros grandes grupos: Java, C/C++, lenguajes .NET (VB.NET, C#), PHP, como claros grupos líderes.

Pienso que, como desarrolladores de software, debemos tener contacto con esos cuatro grupos, y además, con alguno de los “otros”, para aprender otras ideas y formas de programar.

No me enojo si intentan ver AjLisp o AjBasic… :-)

Nos leemos!

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

Aguante el Logo

lopez — Tue, 23 Jun 2009 14:15:00 GMT

Sandra, de la provincia de Tucumán, Argentina, produjo este video, usando el lenguaje Logo, parece que con el FMSLogo.

(Please visit the site to view this media)

Durante el video, visita el sitio del bueno de Daniel Ajoy:

http://neoparaiso.com/

Donde tenemos información sobre el lenguaje y trabajos relacionados de Logo:

http://neoparaiso.com/logo/

Ya escribí sobre Logo, mostrando el trabajo del bueno de Marcelo Dushkin sobre ese lenguaje, en la variante XLogo, con robótica:

Mi primer robot, con XLogo y Rasti

Mi primer robot

No tengo más información sobre Sandra. Pueden visitar su usuario en Youtube

http://www.youtube.com/user/educainformatica

El foro que menciona en el video, al que estoy suscripto, es:

http://groups.google.com/group/logoes

Más información sobre versiones de Logo en:

http://neoparaiso.com/logo/#sect3
http://neoparaiso.com/logo/logoes-mswlogo.html

Mis enlaces sobre este lenguaje, desde:

http://delicious.com/ajlopez/logo

Para los que les gusta más la programación, recomendaría darle un visita al NetLogo:

http://ccl.sesp.northwestern.edu/netlogo/

NetLogo is a cross-platform multi-agent programmable modeling environment.

Si, imaginaron bien, hay un pichón de AjLogo en:

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

Nos leemos!

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

PyCon 2009 Argentina

lopez — Fri, 05 Jun 2009 09:57:00 GMT

La gente de PyCon Argentina http://ar.pycon.org/ está organizando la Primera Conferencia Argentina de Python, a realizarse en Buenos Aires, el 4 y 5 de Setiembre de 2009.

Pueden encontrar más información en

http://ar.pycon.org/2009/about/

Hay Charlas Plenarias, Charlas Programadas, Charlas Relámpago (hay que ir preparado para hablar!) Todavía faltan definir varios puntos, creo que no está decidido el lugar de la reunión.

Pero ya hay un “Call for Papers”

http://ar.pycon.org/2009/charlas/

PyCon Argentina - http://ar.pycon.org/

Primera Conferencia Argentina de Python

Buenos Aires - 4 y 5 de Septiembre de 2009

PyAr, el grupo de usuarios de Python de Argentina llama a la participación de la comunidad de usuarios de Python y Software Libre a la Primera Conferencia Argentina de Python.

En este evento nos juntaremos desarrolladores avanzados y principiantes de Python para intercambiar información, compartir experiencias, analizar nuevas tecnologías, y en general aprender más de este lenguaje a través de la comunidad de Python Argentina.

El autor de cada charla seleccionada podrá participar presencialmente, como orador en el evento. En los casos en que la charla sea realizada por varios autores, se permitirá un máximo de 3 oradores.

Aclaración: Por cuestiones presupuestarias, sólo podrá abonar algunos de los pasajes, total o parcialmente, a los autores seleccionados que residan fuera de Capital Federal o Gran Buenos Aires.

Agradecemos la contribución de todos en la difusión de este llamado y del evento en si mediante los banners diseñados para tal fin y que se encuentran la sección Ayudanos - Difundir

Dónde enviar las Charlas

Las charlas deben ser enviadas para su aprobación a través de este sitio, en Conferencia - Propuestas - Enviar La fecha límite de envío de charlas es el 29 de Junio inclusive. En caso de consultas o inconvenientes, contactarse con charlas@ar.pycon.org

Cómo enviar las Charlas

El envío de la propuesta de charla debe tener los siguientes datos:

Título:

Autor(es): Nombre y apellido, breve descripción de cada uno, foto, asociación, grupo de usuarios, organismo, o empresa a la que pertenece, si corresponde.

Tiempo estimado de duración: Las charlas generalmente son de 45'. En caso de que sea mayor o menor el tiempo requerido solicitamos su justificación.

Breve descripción de la charla: Uno o dos párrafo(s) que explique -no tan brevemente- el contenido de la presentación.

Nivel objetivo de la charla: Clasificar dentro de: introductorio/intermedio/avanzado/experto

Tipo de publico: Desarrolladores avanzados, desarrolladores principiantes, empresarios, docentes, público en general

Conocimientos previos: Especificar que conocimientos previos deberán tener los asistentes.

Tags: web, gui, databases, frameworks, orm, ide, ciencia, educación, juegos, comunidad, etc.

Teléfono del/los autor/es: Para poder comunicarnos.

Ciudad de residencia del/los autor/es.

Qué formato deben tener las Presentaciones

El envío de las diapositivas y/o presentaciones debe tener alguno de los siguientes formatos:

Openoffice.org presentation

HTML standard

Postscript

PDF

Texto plano

Licencia

Debe especificarse una licencia que permita que PyAr distribuya el material en un CD-Live o de Documentación y que permita ser descargado del sitio web de PyAr. Se recomienda Creative Commons o similares.

Es interesante que la comunidad de desarrolladores de Python vaya organizando este tipo de eventos. Espero que sea un éxito.

Nos leemos!

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

Presentando AjCat

lopez — Wed, 29 Apr 2009 10:24:00 GMT

Hace algo más de un mes, estuve trabajando en un intérprete del lenguaje Cat:

The Cat Programming Language

Cat is a functional stack-based programming language inspired by the Joy programming language. The primary differences is that Cat provides a static type system with type inferencing (like ML or Haskell), and a term rewriting macro language extension language called MetaCat.

Cat is a high-level intermediate language translation that can also be used as a stand alone language for simple application development. In this way it occupies a similar niche to PostScript. Cat is also an appropriate language for teaching of basic programming concepts.

Si no conocen el lenguaje Cat, recomiendaría leer:

Cat Tutorial
Cat Specification
Cat Primitives

Publiqué el código como parte de mi proyecto Code Katas en Google Code. El nombre que usé es AjCat:

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

La solución tiene tres proyectos:

La actual implementación no es completa. Solo soporta enteros, todavía no soporta objetos .NET, y no hay primitivas de gráficos. Pero está implementado gran parte de las primitivas y funciones definidas en Cat.

Corriendo el programa de consola, pueden ingresar y evaluar expresiones:

Este código está dedicado a Rodolfo Finocchieti (@rodolfof en Twitter) quien me dejó un comentario acá en este blog, comentándome de este lenguaje Cat, una idea fascinante.

Los tests están en verdes:

Y hay un buen code coverage

Como siempre, me divertí escribiendo este código.

Nos leemos!

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

Enjoying Eric Clapton Everyday I Have the Blues Live

TDD and Code Kata: Writing a Lexer for AjRuby

lopez — Thu, 12 Mar 2009 05:11:00 GMT

Muchas veces, escribo programas tipo code kata, para entrenarme en algún tema de desarrollo de software. En estos últimos meses, escribí varios mini intérpretes, usando TDD, code coverage, y C#. La semana pasada, estuve trabajando en el lanzamiento de otro pet project, AjRuby. El punto de inicio: el analizador léxico, el lexer.

Un lexer es un programa que analiza el código fuente de un programa, y retorna sus tokens, las “palabras” que componen el programa. En el caso de AjRuby, escribí un lexer que sigue la gramática de Ruby. No está completo aún, pero funciona.

Pueden ver el progreso del proyecto, en el repositorio de Google Code:

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

La solución tiene un proyecto de librería de clases, y otro de tests:

Hay una clase Token, que representa cada token:

    public class Token
    {
        public string Value { get; set; }

        public TokenType TokenType { get; set; }
    }

El TokenType es una enumeración:

    public enum TokenType
    {
        Name,
        Integer,
        Real,
        Boolean,
        String,
        Operator,
        Separator
    }

Hay una clase LexerTest.cs, conteniendo tests como:

        [TestMethod]
        public void ShouldProcessName()
        {
            Lexer lexer = new Lexer("name");

            Token token;

            token = lexer.NextToken();

            Assert.IsNotNull(token);
            Assert.AreEqual(TokenType.Name, token.TokenType);
            Assert.AreEqual("name", token.Value);

            token = lexer.NextToken();

            Assert.IsNull(token);
        }

Hay un test para cada tipo de token a ser procesado. Otro ejemplo:

        [TestMethod]
        public void ShouldProcessNameWithInitialUnderscore()
        {
            Lexer lexer = new Lexer("_name");

            Token token;

            token = lexer.NextToken();

            Assert.IsNotNull(token);
            Assert.AreEqual(TokenType.Name, token.TokenType);
            Assert.AreEqual("_name", token.Value);

            token = lexer.NextToken();

            Assert.IsNull(token);
        }

Escribí los tests usando ideas TDD: escribir el test, compilar con error, arreglar los problemas de compilación, ejecutar los tests en rojo, arreglarlos, conseguir el verde para los tests. No estuve haciendo tanto refactoring. El código merece algún refactor, pero por ahora, estoy tratando de conseguir un lexer que trabaje. Los tests quedaron en verde:

Mi objetivo es tener más del 80% de code coverage, en cualquier momento del desarrollo del proyecto:

Es bueno escribir algo sólo por diversión y aprendizaje. Para mí, es parte de la mejora continua que todo desarrollador de software debe perseguir.

Nos leemos!

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

Presentando AjLambda: implementación de Cálculo Lambda en C#

lopez — Thu, 26 Feb 2009 08:19:43 GMT

Estuve trabajando en my "code kata" AjLambda, una implementación de Cálculo Lambda escrita en C#:

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

(Si no conoce el cálculo lambda, hay enlaces sobre el tema al final de este post)

La solución es simple, contiene tres proyectos:

Es una librería núcleo, AjLambda, un proyecto de test AjLambda.Tests y un programa de consola AjLambda.Console para ejecutar. El núcleo tiene unas pocas clases principales:

Expression es la clase base abstracta. .Reduce es el método que implementa la reducción de una expresión. .Replaces se usa para cambiar una variable por otra. Algunas veces, es necesario elegir un nuevo nombre para una variable, que no colisione con otros nombres de variables libres. .FreeVariables es el método para obtener la lista de variables libres en una expresión. Por ejemplo, en la expresión lambda:

\x.xy

x e y son variables, pero y es una variable libre, mientras que x es un parámetro ligado.

Variable expresa una variable (una letra minúscula, en esta implementación). Lambda es la lambda (parámetro más cuerpo). La lambda identidad se ingresa:

\x.x

La versión con múltiples parámetros está soportada:

\xy.yx

Como ejemplo, ésta es la implementación de .Reduce para Pair (un pare de expresiones, left and right):


        public override Expression Reduce()
        {
            if (this.left is Lambda)
                return ((Lambda)this.left).Apply(this.right);

            Expression newLeft = this.left.Reduce();

            if (newLeft != this.left)
                return new Pair(newLeft, this.right);

            Expression newRight = this.right.Reduce();

            if (newRight == this.right)
                return this;

            return new Pair(newLeft, newRight);
        }

Ejecutando AjLamnda.Console con un parámetro:

AjLambda.Console Boot.l

lee y procesa el archivo auxiliar Boot.l, donde definí algunas funciones predefinidas:

; True
T = \xy.x
; False
F = \xy.y
; And
AND = \ab.abF
; If Then Else
IFTHENELSE = \x.x
; Natural numbers
0 = \fx.x
1 = \fx.fx
2 = \fx.f(fx)
3 = \fx.f(f(fx))
; Succesor
SUCC = \nfx.f(nfx)
; Add
ADD = \nmfx.nf(mfx)
; Multiply
MULT = \nmf.n(mf)
; Is Zero
ISZERO = \nxy.n(\z.y)x
; Predecessor
PRED = \nfx.n(\gh.h(gf))(\u.x)(\u.u)
; Pair Functions
PAIR = \xyf.fxy
FIRST = \p.pT
SECOND = \p.pF
NIL = \x.T
NULL = \p.p(\xy.F)
; Fixed Point
A = \xy.y(xxy)
Y = A A
; Factorial
FACT = Y (\f.\n.IFTHENELSE (ISZERO n) (1) (MULT n (f (PRED n)))))

Podemos preguntar por los nombre predefinidos. Están definidos los primeros números naturales, incluyendo el cero:

Los nombres son palabras que comienzan con una letra mayúscula (o números). Los nombres de variables son letras minúsculas (desde 'a' a 'z', una sola letra).

Como es usual, definí SUCC and PRED (funciones sucesor y predecesor):

Cada paso de reducción se imprime, hasta que no es posible más reducción.

Podemos definir nuevas funciones usando Name = <expression>:

Más información sobre Cálculo Lambda en:

Lecture Notes on the Lambda Calculus (pdf) (excelente paper para estudiar Lambda Calculus)

Peter Selinger- Papers

Lambda calculus - Wikipedia, the free encyclopedia

A Tutorial Introduction to the Lambda Calculus

http://delicious.com/ajlopez/lambda

Lambda Calculus implementation from Fred's Page

Nos leemos!

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

Bertrand Meyer en Buenos Aires, Argentina

lopez — Sat, 07 Feb 2009 11:15:56 GMT

Recibo en estos días, un email, avisando de una charla de Bertrand Meyer, aquí, en Buenos Aires. Meyer es uno de los padres de la programación orientada a objetos con contratos, y creador del lenguaje Eiffel. Para ver en qué está trabajando, lo mejor es visitar su página en el sitio de Software Engineering del famoso ETH Zurich:

http://se.ethz.ch/~meyer/

(en mis intereses, ETH Zurich es también conocido por su trabajo en física y ciencias naturales, vean algunos de los premios Nobel que pasaron por ahí http://www.ethz.ch/about/bginfos/nobelprize/index_EN).

La charla es gratuita, no necesitan inscribirse, y es parte de los Seminarios Athena, de la gente de la Universidad Tecnológica Nacional, de Buenos Aires.

Para más información sobre los seminarios Athena (charlas anteriores,charlas futuras, comentarios, etc)
ver: http://www.seminariosathena.com.ar/

Como en esta seminario, en esas charlas no es necesaria inscripción previa ni conocimientos de alguna tecnología en particular.

El titulo del seminario es Touch of Class: How we teach introductory programming. Y será dado el próximo miércoles 11 de febrero. El lugar, el aula magna de Medrano 951, Buenos Aires, a las 19.00 hs. Está basado en el libro que publicó Meyer este año, con el mismo título.

El abstract en inglés:

Teaching programming faces a host of challenges, due in particular to the unprecedented variety of student backgrounds and to the demands of the IT industry. Techniques that worked well in the seventies do not scale up to today's context. The "concepts or skills?" debate is more relevant than ever, especially in the ever more globalized world of software development.
For the past 6 years, we have taught introductory programming at ETH, based on an "outside-in" approach that makes it possible to introduce the reality of large software while emphasizing the principles of sound software development. This approach has resulted in a forthcoming textbook ("Touch of Class: An Introduction to Programming Well With Objects and Contracts", Springer-Verlag, May 2009).
I will present the result of our experience, including metrics that we have systematically collected along the way, and draw conclusions regarding how to teach programming today. I will argue the task consists of teaching twenty-six seminal concepts, and will explore one of them in depth.

Hay otra charla el jueves, esta vez en la Facultad de Ciencias Exactas, de la Universidad de Buenos Aires. La charla sera en el aula 4 del Pabellon I de la Facultad de Ciencias Exactas y Naturales, en Ciudad Universitaria.

Programs that test themselves
Bertrand Meyer, ETH Zurich and Eiffel Software

"Automated" testing techniques as widely used today automate only part of the task, but leave aside the most difficult and time-consuming aspects: test case generation and test oracles. Using software with built-in contracts addresses both of these issues, leading to software that tests itself completely automatically, in a
"push-button" style.

The talk will present concepts and principles behind push-button contract-based testing and present experiences with two tools, AutoTest and CDD (Contract-Driven Development), which have already uncovered
hundreds of bugs in released commercial software and have now been integrated as a standard component of the EiffelStudio IDE.

Bertrand Meyer is Professor of Software Engineering at ETH Zurich and Chief Architect of Eiffel Software. He is the author of a number of books including the best-seller "Object-Oriented Software Construction" (Prentice
Hall, Jolt Award 1998). He has led the development of the Eiffel language and supporting tools and libraries. He is a fellow of the ACM and has received the ACM Software System Award as well as the Dahl-Nygaard prize for
object technology and an honorary doctorate from the Technical University of Saint Petersburg. His latest book is "Touch of Class", an introductory programming textbook to be published in May 2009 by Springer.

Recuerdo haber leído varias veces, el libro de Meyer: "Object-Oriented Software Construction". Es un libro que merece ser releído cada tanto tiempo. Totalmente recomendable. Ahí encontré por primera vez al lenguaje Eiffel, y los contratos, muy interesante. Temo que Eiffel me chocó un poco, por el uso de mayúsculas, que en aquellos años me recordaban a Cobol y Ada. Recuerdo que en aquellos tiempos, Eiffel tenía renaming de clases, cuando había colisión de nombres. No había lenguajes con claros Namespaces, que aparecieron luego como extensión de C++.

Espero que Meyer disfrute de la visita a mi país. Aun en el mundo de Internet, es importante el contacto personal. Es muy bueno que gente de la industria y de la academia, venga a visitarnos. Muy bueno, también, que la UTN y la UBA hayan podido organizar estas charlas.

Si conocen otras actividades de Meyer en mi país, dejen comentario!

Nos leemos!

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

Un ejemplo de Dynamic Expressions

lopez — Sat, 31 Jan 2009 09:01:50 GMT

El jueves, estaba preparando una presentación para ayer viernes, explicando cálculo lambda, su historia, su aplicación en lenguajes de programación. Al final de la presentación, mostré cómo las lambdas llegaron a .NET: delegados, notación lambda y expresiones lambda.

Haciendo una rápida búsqueda de enlaces para la charla, encontré esta implementación "cool" de un "parser" de expresiones dinámicas, en el ejemplo:

DynamicLinq.cs

Ese código menciona el post de Scott Guthrie:

Dynamic LINQ (Part 1- Using the LINQ Dynamic Query Library)

El código está incluido en el directorio DynamicQuery en:

C# Dynamic Query Library (included in the -LinqSamples-DynamicQuery directory)

Mi idea inicial para la charla era describir una fórmula y compilarala, usando System.Linq.Expressions. Pero la implementación de arriba, tiene una característica notable: en lugar de construir un árbol de expresiones, paso a paso, creando cada nodo, toma un string y los analiza en el momento, convirtiéndolo a una versión compilada.

OK, este truco es usado por muchas implementaciones de query en Linq, pero no conocía que entre el código de ejemplo de Microsoft estuviera este código.

Usando el DynamicLinq.cs, pude crear una aplicación WinForm, donde la fórmula se ingresa y se compila en el momento:

Vean que podemos usar clases de .NET. "x" es el parámetro que uso como variable en el cálculo de la fórmula.

Este es el código clave en el archivo Calculator.cs:

        public Delegate CompileFormula(string formula)
        {
            ParameterExpression x = Expression.Parameter(typeof(double), "x");
            LambdaExpression e = DynamicExpression.ParseLambda(new ParameterExpression[] { x }, null, formula);
            return e.Compile();
        }

El delegado compilado puede ser invocado, proveyendo el valor del parámetro "x":

        public double[] Calculate(Delegate formula, double from, double to, double step)
        {
            List<double> values = new List<double>();

            for (double x = from; x <= to; x += step)
                values.Add((double) formula.DynamicInvoke(x));

            return values.ToArray();
        }

Pueden descargar este ejemplo de:

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

Otra implementación de expresiones dinámicas compiladas:

To Bind or Not To Bind – Dynamic Expression Trees – Part 3 - B# .NET Blog
To Bind or Not To Bind – Dynamic Expression Trees – Part 2 - B# .NET Blog
To Bind or Not To Bind – Dynamic Expression Trees – Part 1 - B# .NET Blog

Algunas ideas a explorar:

- Extender el ejemplo a tres dimensiones (podría usar un ejemplo que viene en F# con DirectX como base)

- Enviar una fórmula como texto, para ser procesada en una aplicación distribuida, grilla, o cluster de HPC. Por ejemplo, la fórmula del fractal a calcular en forma distribuida.

- Code kata escribiendo mi propio .Parse y .Compile para alguno de mis lenguajes de scripting

Si necesitan más poder, el próximo nivel de lenguajes dinámicos y su compilación a .NET, ese el namespace Microsoft.Scripting dentro del código fuente de IronPython:

http://www.codeplex.com/IronPython/SourceControl

Introducciones a IronPython y la iniciativa DLR:

CLR Inside Out- IronPython and the Dynamic Language Runtime
CLR Inside Out- Dynamic Languages and Silverlight
InfoQ- Microsoft Surpasses Java's Dynamic Language Support-
CLR Inside Out - IronPython

Enlaces relacionados sobre lambda, Dynamic Language Runtime, y lenguajes dinámicas en general:

http://delicious.com/ajlopez/lambda
http://delicious.com/ajlopez/dlr
http://delicious.com/ajlopez/dynamiclanguages

Nos leemos!

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

Presentando AjSoda

lopez — Mon, 26 Jan 2009 08:46:29 GMT

Hace un año, escribí un post, comentando el trabajo de Ian Piumarta work:

Self-sustaining sysmtes, Cola, Pepsi y Mate

Proponía que una implementación de las ideas Ian Piumarta y Warth, era posible en .NET o en Java. En vez de usar C como lenguaje base, se podría implementar todo sobre un lenguaje con máquina virtual, con un framework rico de clases de base, y con un garbage collector automático. Para mí, era una interesante idea, que merecía algo de atención.

Para entender las ideas ideas de Piumarta y Warth, lean lo que describieron sobre una implementación mínima en:

http://piumarta.com/pepsi/objmodel2.pdf
http://piumarta.com/pepsi/objmodel.pdf

Encontrarán el código de una implementación en C, en esos papers. Un diagrama aclaratorio:

(tomado deOpen Extensible Dynamic Programming Systems Dls )

Esta semana pasada, puse manos a la obra, y estuve trabajando en una implementación en C# de esas ideas. Publiqué mi código en my Proyecto Google Code AjCodeKatas, dentro de:

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

La solución tiene cuatro proyectos (dos librerías de clases, y otros dos que son sus respectivos tests). El proyecto principal es el AjSoda:

Un diagrama de las interfaces principales:

IObject es la interfaz que escribí para representar un objeto genérico. Tiene un "payload", que es un arreglo de referencias a objectos .NET arbitrarios.

Una alternativa que consideré, era apuntar solamente a IObjects. Pero quiero tener la capacidad de apuntar y manipular directamente objetos .NET (u objetos Java, si lo reimplemento en ese lenguaje). La alternativa hubiera sido apuntar solo a IObjects, e implementar un digamos DotNetWrapper : IObject que encapsulara los accesos a un objeto .NET (algo así está armado en el AjBasic).

El método más importante en IObject es Send. Usando este método, podemos enviar un mensaje (selector y argumentos) a cualquier instancia de IObject.

IBehavior es mi implementación de lo que Piumarta y Warth llaman una vtable (me recuerda a las tablas de métodos en viejas implementaciones de C++). Es un objeto que contiene una lista por nombre de métodos que pueden atender los mensajes que se envía a un IObject.

Cada IObject tiene una propiedad Behavior que apunta a un IObject. Podría haber elegido apuntar a un IBehavior, pero de esta manera, el Behavior de un objeto puede ser reemplazado por cualquier otro objeto que entienda un mensaje con selector #lookup:.

No necesité hasta ahora, implementar el concepto de Closure, como lo describen Piumarta y Warth en su paper. Usando closures, ellos implementan slots a la Javascript o Self. Pero en los experimentos que hice, no necesité aún implementar eso.

Las clases principales de implementación son:

Cada BaseObject implementa un IObject, manteniendo un arreglo interno de objetos como "payload" del objeto:

    public class BaseObject : IObject
    {
        private object[] values;

        public BaseObject()
        {
        }

        public BaseObject(int size)
        {
            this.values = new object[size];
        }

        public int Size
        {
            get
            {
                if (this.values == null)
                {
                    return 0;
                }

                return this.values.Length;
            }
        }

        public IObject Behavior { get; set; }

(Noten que la propiedad Behavior es un IObject, por las razones que expliqué antes).

El método más interesante es el Send:

        public virtual object Send(string selector, params object[] arguments)
        {
            if (selector == null)
            {
                throw new ArgumentNullException("selector");
            }

            if (this.Behavior == null)
            {
                throw new InvalidOperationException("No behavior in object");
            }

            IMethod method = (IMethod) this.Behavior.Send("lookup:", selector);

            if (method == null)
            {
                throw new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, "Unknown message '{0}'", selector));
            }

            return method.Execute(this, arguments);
        }

No uso directamente this.Behavior.Lookup para obtener el IMethod asociado a un selector. En cambio, uso directamente el método Send para enviar un mensaje al object apuntado por Behavior. De esta forma, obj.Behavior puede ser dirigido a cualquier objeto IObject que quiera implementar la lógica de lookup de un método por selector. Esta decisión tiene impacto en el rendimiento, pero permite explorar nuevas estrategias de obtención de métodos. Pueden leer en los papers mencionados, cómo implementan herencia múltiple y Traits, usando esta capacidad de redefición de lookup.

AjPepsi

En el código encontraran un proyecto adicional, AjPepsi, donde implementé un parser, y intérprete de bytecodes, de un lenguaje parecido al que usaron language Piumarta/Warth como prueba de concepto en sus escritos. Acepta código como:


Object new [^self class basicNew initialize]
Object initialize []

List : Object(head tail)

List head [^head]
List tail [^tail]
List head: newHead [head := newHead]
List tail: newTail [tail := newTail]

list1 := [^List new]
list2 := [^List new]

[list1 head: 'Hello']
[list2 head: 'World']
[list1 tail: list2]

Object y List son prototipos. Dejaré una explicación más detallada de este lenguaje y su implementación para un futuro post. AjPepsi aún está en desarrollo; probablemente, refactorearé gran parte del núcleo de la implementación. Tomé el código de AjTalk como base, pero no estoy seguro de haber tomado la decisión correcta: AjPepsi es muy orientado a prototipos, y basado en AjSoda, así que tuve que trabajar bastante para llevarlo a estas ideas.

Una gran "feature" pendiente: generar código C# a partir del estado de la máquina virtual (clases, métodos e instancias). Vean en el sitio de Piumarta cómo implementó un compilador de su propio lenguaje en C, y que genera en ese lenguaje el código de su propio intérprete. De ahí la idea de "lenguajes auto sustentables".

Los tests están en verde:

El "code coverage" es bueno:

Hay algún "code smell" para refactorear. Un ejemplo clásico: el gran switch con toneladas de código en el intérprete de byte code. Pero la mayoría de ese código oloroso está en el proyecto AjPepsi. AjSoda está tomando forma, yendo hacia una versión estable. Me tomó sólo 4 horas escribir el código de AjSoda, pero estoy gastando muchas horas escribiendo AjPepsi (10 horas hasta ahora).

Como de costumbre, ¡me divertí escribiendo este código!

Más enlaces sobre las ideas de Piumarta/Warth:

http://lambda-the-ultimate.org/node/2483
http://piumarta.com/
http://piumarta.com/pepsi/pepsi.html
http://piumarta.com/software/cola/

Comentarios, sugerencias, bienvenidos.

Nos leemos!

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

Clean Code Talks -- Herencia, Polimorfismo y Tests

lopez — Tue, 13 Jan 2009 09:15:54 GMT

Son un usuario fanático de Twitter. Una cuenta a la que sigo es @delicious_prog, que envía varios mensajes por día, relacionados con programación, desarrollo de software en general. En uno de esos tweets, encontré el post

The Clean Code Talks -- Inheritance, Polymorphism, & Testing

de Daniel Wild, donde incluye el vidio de una Google Talk:

(Please visit the site to view this media)

de Misko Hevery en Google Tech Talks.

Es claro e interesante. Es una charla explicando los usos del polimorfismo, y también, las formas de realizar test sobre métodos polimórficos. Me gusta encontrara en este vido varios argumentos similares a los que uso en mis charlas de desarrollo. Hace unos días, estuve usando polimorfirsmo en mi intérprete AjCat (un intérprete del lenguaje cat que me hizo conocer el bueno de @rodolfof):

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

Esta es mi implmentación de Integer Binary Operation:

    public abstract class IntegerBinaryOperation : Expression
    {
        public abstract int Apply(int op1, int op2);

        public override void Evaluate(Machine machine)
        {
            int op2 = (int) machine.Pop();
            int op1 = (int) machine.Pop();

            machine.Push(this.Apply(op1, op2));
        }
    }

Las operaciones Add y Subtract sobreescriben el método Apply:

    public class IntegerAddOperation : IntegerBinaryOperation
    {
        private static IntegerAddOperation instance = new IntegerAddOperation();

        private IntegerAddOperation()
        {
        }

        public static IntegerAddOperation Instance
        {
            get
            {
                return instance;
            }
        }

        public override int Apply(int op1, int op2)
        {
            return op1 + op2;
        }

        public override string ToString()
        {
            return "add_int";
        }
    }

    public class IntegerSubtractOperation : IntegerBinaryOperation
    {
        private static IntegerSubtractOperation instance = new IntegerSubtractOperation();

        private IntegerSubtractOperation()
        {
        }

        public static IntegerSubtractOperation Instance
        {
            get
            {
                return instance;
            }
        }

        public override int Apply(int op1, int op2)
        {
            return op1 - op2;
        }

        public override string ToString()
        {
            return "sub_int";
        }
    }

Es muy similar al ejemplo presentado en el video. Estuve algo más perezoso en mi implementación de operadores en AjPython (otro intérprete, de nuevo en C#, trabajo en progreso):

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

    public class BinaryOperatorExpression : BinaryExpression
    {
        private Operator @operator;

        public BinaryOperatorBLOCKED EXPRESSION;
        }
    }

Pero confío en refactorearlo, tengo espaldas para hacerlo, gracias una buena base de test ya escritos.

Es bueno encontrar este tipo de material, como esta charla, la recomiendo, gracias a @delicious_prog y a Daniel Wild!

Nos leemos!

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

Resultados de la Semana Sabática

lopez — Sat, 25 Oct 2008 08:58:04 GMT

Desde el 19 al 29 de septiembre pasado, tuve mi segunda semana sabática del año, sin cursos, sin entrevistas, sin charlas, dedicadas a desarrollo y estudio. Había publicado lo que quería hacer y producir en esa semana.

Segunda Semana Sabática del año

Ya pasó el tiempo, es hora de escribir los resultados. Creo que nos sirve escribir lo que uno quiere hacer, y también publicar los resultados. Así que estos post, el anterior y el actual, son algo necesario para el proceso: son parte de los "deliverables" del proyecto.

La lista a producir y lo producido:

- Terminar una primera versión ejecutable de mi intérpreta AjSharp, similar en sintaxis a C#, ahora en desarrollo dentro de mi proyecto AjBasic. COMPLETO Pueden ver el resultado en el código del proyecto, donde quedaron dos nuevas solucíones que definen el nuevo lenguaje. Escribí un post explicando algo de la implementación en

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

- 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. COMPLETO Finalmente quedó implementado. Escribí sobre el tema en

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

También hay ideas nuevas para implementar:

Otro modelo para AjGenesis

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

- 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. COMPLETO Ahora se puede cargar código desde archivos .st, pueden ver algunos tests en el código publicado. Faltan varios detalles de lenguaje y parseo mismo, como el soporte de bloques entre [ y ] y la invocación de primitivas desde ese texto a cargar, y el manejo de variables indexadas. Luego de la semana sabática, seguí probando el nuevo Loader, y está interesante: es cuestión de completar esos puntos y comenzar a implementar la librería base. Estoy estudiando la implementación que viene con Smalltalk/X.

- Escribir dos posts sobre AjGenesis. COMPLETO Fueron los post

Generación de código para LINQ y C# 3.0 con AjGenesis

y el ya mencionado

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

- Escribir dos posts sobre F#, para ir adelantando temas para el próximo TechNight. PARCIAL Escribí un post sobre

Recursos de F# y Programación Funcional

pero no el segundo. Como compensación, escribí en detalle sobre la charla del TechNight en

Babel de lenguajes en .NET

- Escribir dos posts que traten sobre CCR (Concurrent and Coordination Runtime) de Microsoft Robotics. PENDIENTE Tengo escrito un ejemplo corto introductorio, pero falta pulirlo.

No hubo "overdeliveries" en el producto de la semana, pero con el impulso de lo hecho y estudiado en la semana sabática, luego aparecieron:

http://code.google.com/p/ajfunc Implementación de un lenguaje funcional, AjFunc, siguiendo la sintaxis y semántica de F#. Falta el soporte de inferencia de tipos, y mil detalles más. Pero ya va tomando forma el núcleo.

http://code.google.com/p/ajlogo Una implementación del lenguaje Logo. Dando los primeros pasos.

http://www.codeplex.com/ajmessages La publicación de un AjMessages sobre DSS/CCR. Lo había escrito el año pasado, pero ahora lo actualicé, lo pulí un poco. El año pasado también hubo un ejemplo sobre WCF. Próximos pasos: unificar los ejemplos, mejorar la serialización de los objetos, mejorar la configuración. Un post describiendo algo de la nueva implementación en:

Aplicaciones distribuidas con AjMessages usando DSS/CCR

Como en otras semanas sabáticas, me divertí muchísimo, y aparte me entrené y aprendí cosas nuevas.

Nos leemos!

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

Babel de lenguajes en .NET

lopez — Thu, 16 Oct 2008 12:03:30 GMT

El viernes pasado tuve el gran gusto de compartir un TechNight con los buenos de Martín Salías y Rodolfo Finocchieti, en temas que nos gustan a los tres: lenguajes de programación, en este caso, implementados sobre .NET. Ya habíamos preanunciado el evento en:

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

(bueno, me gustó la imagen que usé entonces para ilustrar mi post, así que la repito acá... ;-).

Desde que tengo memoria, ha habido lenguajes de programación y más lenguajes de programación. En mi tierna infancia ya había varios lenguajes (sí, algunos mal intencionados van divulgando por ahí que cuando yo era un infante, había una sola masa continental, pero son rumores infundados... ;-).

Recuerdo un artículo de los 60 del Scientific American, donde se mostraba un lenguaje propuesto, no totalmente desarrollado, el CPL (Combined Programming Language). Recordaba vagamente que era parte de un trabajo de Christopher Strachey, hoy lo pueden comprobar en el corto artículo de la Wikipedia sobre CPL. (Bien! la neurona todavía me trae recuerdos más o menos "accurate"...;-).

Se vió que era un lenguaje algo ambicioso. Yo llegué a programar con una versión simplificada, el BCPL, de Martin Richards que tenía algo que me sigue fascinando: su compilador estaba escrito en BCPL, así que bastaba usar una máquina que tuviera implementando BCPL para poder ir armando otros compiladores BCPL en otras máquinas. También se podía generar un O-Code para una máquina virtual, y reimplementar esa máquina virtual en otras computadoras. Desde ideas de BCPL partieron el B y nuestro conocido lenguaje C. Otros intentos de máquinas virtuales fueron el P-Code de Pascal BSD, creo recordar, y también las Smalltalk machine que siempre se pensaron armar sobre ideas de Smalltalk. Siempre es interesante encontrar la idea de un lenguaje que implementa su propio compilador o intérprete. Recuerdo el mítico Small C de Cain y luego Hendrix, que aparecía a principio de los ochenta en Dr. Dobb's. Este año reencuentro esa idea de "lenguajes auto sustentables" en Self-sustaining Systems, Cola, Pepsi, Coke y Mate.

Hoy no podemos hablar, como antes (algunas décadas), de "yo programo en X (un solo lenguaje)". Cada vez más, tenemos más opciones. Habrá que ver que no todas son potables para todos los trabajos. Pero pienso que debemos de vez en cuando, sumergirnos en el estudio de otros lenguajes, para tener una visión más amplia, ejercitar la neurona, y tener una nueva "tool" en nuestra caja de herramientas.

En los noventa, nos encontramos de nuevo con el auge de las máquinas virtuales, con la aparición de Java. Con el nacimiento de .NET, tenemos una máquina virtual (aunque alguien de Microsoft se atragantaría con su lengua antes de denominar al CLR, Common Language Runtime, como máquina virtual).

Es sobre .NET y su máquina virtual, donde aparecieron múltiples implementaciones de lenguajes. Pero basta de historia, y pasemos a la charla en sí.

La charla

Excelente lo que mostraron Martín y Rodolfo. Yo comenté algunos temas de programación funcional, orientados a F#, basado en ejemplos que vienen con el lenguaje, y de libros. Los recursos que utilicé y nombré estan en mi anterior post:

Recursos de F# y Programación Funcional

Quisiera poner acá un resumen de lo que mostraron Martín y Rodolfo.

Rodo se dedicó a comentar en particular dos lenguajes, Boo y Cat, además de seguir comentando sobre las ideas de funcional. También mostró un Toy language, implementado usando las capacidades de Dynamic Language Runtime (Rodolfo, no encontré si está disponible ese ejemplo). Pueden bajarse su presentación desde

TechNight: programming in Babel

Boo lenguaje de programación creado por Rodrigo Barreto de Oliveira. Pueden leer el Boo Manifesto para conocer más sobre la historia del lenguaje. Rodrigo necesitaba un lenguaje que se adaptara a lo que necesitaba programar, y como no encontraba ninguno que diera la talla, se lanzó a crear su propio lenguaje. El estaba entusiasmado con Python, pero en esos momentos no lo podía usar en el proyecto que tenía que desarrollar. Boo tiene una sintaxis inspirada en Python, declaración automática de variables, inferencia automática de tipos, casteo de tipos automático, funciones como objetos y ciudadanos de primera clase en el lenguaje, duck typing (la gente de Smalltalk reconocerá el concepto, y se asombrará de que exista como tal, para ellos es parte de la naturaleza misma). Rodolfo nos fue mostrando todos estos conceptos, pueden ver más detalles en la presentación que dejó disponible.

Otro lenguaje que mostró fue Cat Programming Language. Conocí este lenguaje gracias al bueno de Rodolfo, que me dejó un comentario en este blog (eso es cumplir con Don't be a Canuto, bravo!). Es un lenguaje funcional, orientado a pila, que nació de otro trabajo en Java, el Joy Programming Language. La primera vez que lo ví, me recordó a mi querido Forth (aún debo tener en algún cubil mío, la Dr. Dobb's dedicada a ese lenguaje). Lo que me comentó Rodolfo el viernes, es lo simple que es la solución de código: podemos recorrerla y entenderla. Es un caso de estudio abordable de generación de código compilado en .NET, con instrucciones de Intermediate Language. Vean también cómo un lenguaje definido se puede reimplementar en otros. Lo tienen en JavaScript Online Cat interpreter , en Cat in Scheme, Cat in Python, Cat in Haskell, Cat in Haskell using monads, y en Cat in Omega. ¿Tendré que pasarlo a ajlisp o ajbasic? ;-)

En su turno, Martín Salías siguió comentando sobre implementaciones de lenguajes en Dynamic Language Runtime, en especial la historia de IronPython, creado por Jim Hugunin. Jim es el creador de Jython, la implementación de Python sobre Java, y quería demostrar que la máquina virtual de .NET no era adecuada para implementar un lenguaje dinámico como Python. Y se lleva la sorpresa de poder hacerlo mejor que en Java. Así va naciendo lo que ahora conocemos como Dynamic Language Runtime, un nuevo namespace de código abierto, que crea Jim dentro de la implementación de IronPython, y que podemos usar para implementar otros lenguajes. Nos da clases de soporte para armar un árbol de expresiones en memoria, y luego generar código para .NET. No hay un lugar separado para bajarse esas clases, pero pueden obtenerlas desde:

http://www.codeplex.com/IronPython

Es interesantísimo ver la implementación en detalle, en especial los conceptos aplicados sobre DynamicSite, basta como botón de muestra

Martin Maly - Building a DLR Language - Dynamic Behaviors 2

y visitar el blog de Hugunin en MSDN.

Puede ver lo que se está gestando para IronRuby también.

Y comentó sobre todo lo que se está haciendo en JavaScript. Lean su post:

Javascript - La programación del futuro

Mencionó el trabajo del "monstro" de JavaScript, John Ressig:

http://ejohn.org/ en Twitter @jeresig

sobre JavaScript, principal creador del JQuery (agregaría que en estos días, Microsoft ha decidido agregar JQuery a su implementación de ASP.NET Ajax). Martín dejó encantada a la audiencia, mostrando lo que hizo Resig: implementar en JavaScript un lenguaje gráfico Processing pasen, lean y vean:

Processing.js

(imagen tomada de ese post)

Martín comentó que JavaScript corre en el cliente, con lo que se puede poner trabajo no trivial en esa máquina, haciendo más liviano el trabajo del servidor, que tal vez se encargue de darnos datos sin embellecer, el proceso de agrupación, mostrado, gráfico, puede ser derivado al cliente. Igualmente, hay JavaScript en el servidor, leer:

Permanent link to Bringing the Browser to the Server

Ahora que en los browsers está el elemento Canvas, podemos usarlo desde JavaScript, leer

Permanent link to Javascript Sparklines Library

Pero vean hasta donde puede llegar JavaScript, viendo el proyecto del bueno de Dan Ingalls:

Sun Labs Lively Kernel

Más enlaces

Para todos los que les gusta explorar los lenguajes de programación, sus paradigmas, ideas y futuro, algunos enalces recolectados en estos días:

JAOO 2007- Gilad Bracha - Computational Theology, Functional versus Imperative, Language History

Ted Neward- On Java and .NET, Software Academics versus Practioners, General Purpose Programming

Prolog just blew my mind!

Dynamic programming futures InfoWorld Analysis 2008-10-13 By Peter Wayner

Erik Meijer, Gilad Bracha, Mads Torgersen- Perspectives on Programming Language Design and Evolu

Dynamic Languages vs Static Verification - Greg Young [MVP]

Joe Gregorio BitWorking JavaScript is the new Smalltalk

ST2JS - Smalltalk to Javascript translator (el trabajo de nuestro argentino Diego Gomez Deck)

Google Chrome, JavaScript and Smalltalk

La preparación de esta charla, me movió a escribir y actualizar algo de código de mini intérpretes que estoy armando. Pueden ver el estado actual en:

http://code.google.com/p/ajbasic Intérprete, con sintaxis AjBasic y ahora también AjSharp
http://code.google.com/p/ajlisp Intérprete Lisp, bastante terminado
http://code.google.com/p/ajtalk Intérprete bytecodes a la Smalltalk, más adelante podría compilarse
http://code.google.com/p/ajfunc Idem, pero orientado a la F#
http://code.googe.com/p/ajlogo El lenguaje Logo siempre es interesante de investigar

Bueno, como siempre, los enlaces de estos temas, que colecciono, desde:

Nos leemos!

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

Recursos de F# y Programación Funcional

lopez — Sat, 11 Oct 2008 15:53:45 GMT

F# es un lenguaje funcional, creado por Microsoft. Implementado bajo el soporte de .NET CLR, es un lenguaje tipado, con acceso completo al framework de .NET. Hereda características de los lenguajes ML/OCaml, notablemente de este último, el soporte de clases y objetos.

F# nació dentro de Microsoft Research, siendo su principal creador Don Syme. Aunque es un lenguaje funciona, soporta programación de objetos, y no vive en solitario: puede llamarse desde otros lenguajes .NET y puede invocar a librerías escritas en otros lenguajes, lo cual le da una flexibilidad que otros lenguajes más "puros" no tiene. Despues de años de desarrollo, es un lenguaje maduro, que está ganando momento en la comunidad científica, y en otras, como la financiera, que necesitan manipular monedos y operar con fórmulas. Como puede acceder a todo .NET, puede aprovechar otras librerías, como muestra esta imagen, de un programa de demostración que viene en el paquete, donde F# accesde a DirectX desde .NET.

Cito algo de la promoción de Apress sobre el libro Expert F#:

While inspired by OCaml, F# isn't just another functional programming language. Drawing on many of the strengths of both OCaml and .NET, it's a general–purpose language ideal for real–world development. F# integrates functional, imperative, and object–oriented programming styles so you can flexibly and elegantly solve programming problems, and brings .NET development alive with interactive execution. Whatever your background, you'll find that F# is easy to learn, fun to use, and extraordinarily powerful. F# will help change the way you think about and go about programming.

Hay abundante información sobre el lenguaje. Este posts es una actualización de uno anterior, con enlaces, blogs, posts, recursos, libros, sobre este interesante lenguaje. Ya había publicado a fines del año pasado:

Recursos de F#

Enlaces

La primera página a visitar es la página madre de F# en Microsoft:

Microsoft Research's website for F#
F# Manual
F# Documentation

Hay blogs y foros en
hubFS- The place for F# - F# news, forums and blogs

Blogs personales de gente dedicada a F#:
Don Syme's web log, a key source of information on F#
Robert Pickering's blog
Tomas Petricek
Granville Barnett's blog
Luke Hoban's blog
Chris Smith (F# Tester)
Brian McNamara (F# Dev)
Jomo Fisher (F# Dev)
Andrew Kennedy (MSR)
Luca Bolognese (Managed Languages Principal PM)

Harry Pierson ha escrito varios posts sobre programación funcional, no solo para F#, abarca también F#:
DevHawk Functional Programming category

Posts y podcasts

Algunos enlaces a posts (hay cientos en los enlaces de arriba), sólo para que tengan un primer encuentro con el lenguaje y su poder expresivo:

Episode 18- Matt Podwysocki on F# and Functional Programming Herding Code
Matt Podwysocki pone "fun" en programación "fun"cional, con F#.

Concurrency on a single thread
Usando expresiones F# asincrónicamente para escribir programas paralelos.

F# September 2008 CTP Released
El último "release" CTP de septiembre.

F# Overview (I.) - Introduction Articles TomasP.Net

Functional Understanding

Practical F# Parsing- The Parse Buffer

Play Ball Script in F#

Units of Measure in F#- Part One, Introducing Units

The Weekly Source Code 34 - The Rise of F#

Para escuchar

Herding Code 18- Matthew Podwysocki on F# and Functional Programming
Software Engineering Radio Episode 108 - Simon Peyton Jones on Functional Programming and Haskel
.NET Rocks Episode 310 - Simon Peyton Jones on Functional Programming and Haskell

Ejemplos

Además de los ejemplos que vienen con el paquete de distribución, encontraran código para bajarse y probar en lás páginas de los libros mencionados más abajo. Además, tenemos:

F# Samples - Home
Ant Colony Simulation
FsTest
FsUnit

Libros de F#

Estoy leyendo los dos primeros, publico acá algo del resumen publicado por las editoriales para promocionarlos:

Foundations of F#

Every professional .NET programmer needs to learn about FP, and there's no better way to do it than by learning F#--and no easier way to learn F# than from Foundations of F#. Written by F# evangelist Rob Pickering, this is an elegant, comprehensive introduction to all aspects of the language and an incisive guide to using F# for real-world professional development.

by Robert Pickering | ISBN-13: 978-1-59059-757-6 | Published May 2007 | 360pp.

Expert F#

Written by F#'s inventor and two major contributors to its development, Expert F# is the authoritative, comprehensive, and in–depth guide to the language and its use. Designed to help others become experts, the first part of the book quickly yet carefully describes the F# language. The second part then carefully shows how to use F# elegantly for a wide variety of practical programming tasks.

by Don Syme, Adam Granicz, Antonio Cisternino | ISBN-13: 978-1-59059-850-4 | Published Dec 2007 | 609pp.

Otro libro, de Jon Harrop:

F# for Scientists

F# for Scientists will bring you up to speed with basic syntax and programming language concepts. Written in a clear and concise style with practical and enlightening examples, this book is accessible and easy to understand. By reviewing the Visual Studio screen shots that illustrate compilation, debugging and interactive use, you will understand both the functional aspects of F# and the object-oriented task-based features that make F# so useful in practice.

Programación Funcional

Si estamos interesados en la programación funcional en general, podemos visitar:

Functional Programming for the Rest of Us

Why Functional Programming Matters un clásico de John Hughes

Why Haskell Matters

El "paper" clásico de Backus backus.pdf. Backus fue el que puso de nuevo en el tapete a la programación funcional. Recuerdo mis tiempos de "jugar" con APL (A Programming Language).

Un "popurri" de enlaces:

Are FP and OO Incompatible Syntactic Styles-
A Gentle Introduction to Haskell, Version 98
About Erlang
APL (programming language) (uno de los primeros lenguajes con los que me topé)
An APL Compiler (Timothy Budd no deja de escribir libros sobre implementación de lenguajes)
The Cat Programming Language (Gracias a Rodolfo Finochietti por comentarme este lenguaje)
YouTube - Tangible Functional Programming
Functional Programming Notables #1 (más enlaces a programación funcional)
The Little MLer
functional objects Felleisen
Erlang in Lisp
Free Online Functional Programming Books -- FreeTechBooks.com
The Expression Lemma (muy math geek, teoría de categorías, programación funcional y LINQ!! Ideal para internarse una semana)
Chaitin's construction (también math-geeky, más teoría de categorías, Chaitin es argentino, como el mate)
On being stateful
The Glasgow Haskell Compiler
A Neighborhood of Infinity- You Could Have Invented Monads! (And Maybe
InfoQ- Domain Specific Languages in Erlang

C# Funcional

.NET y C# van adoptando con el tiempo algunos estilos funcionales. Todo lo que siempre quiso saber sobre programación funcional con C#, desde el post del bueno de Mattew Podwysocki:

Richmond Code Camp 2008.2 - Functional C# Recap

Otros enlaces:

Functional C# Project
Is C# Becoming a Functional Language- - Mads Torgersen
Functional C# - Learn from F# and LINQ

Mi Delicious

Soy un adicto a Delicious, acá están los tags que uso para estos temas:

http://delicious.com/ajlopez/fsharp
http://delicious.com/ajlopez/f%23
http://delicious.com/ajlopez/functionalprogramming
http://delicious.com/ajlopez/haskell
http://delicious.com/ajlopez/erlang

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