Angel "Java" Lopez : AjBasic

CodeCamp en Buenos Aires: Intérpretes y Compiladores en .NET

lopez — Tue, 31 Aug 2010 09:21:16 GMT

El próximo sábado tendremos CodeCamp en Buenos Aires:

http://www.codecamp.com.ar

Les recomiendo una visita al blog (en la página principal) y a la agenda:

http://www.codecamp.com.ar/agenda.aspx

donde hay actividades y charlas desde la mañana hasta la tarde, sobre Azure, Entity Framework 4, .NET 4, Arquitectura de Software (por @MartinSalias), WPF, IronRuby, DynamicDataCenter, SQL Server, Silverlight, ASP.NET MVC, HyperV, WCF, SQL Azure, HTML5, Windows 7, y demos de las Células (vean por ejemplo el video de Sinergia en una Célula Microsoft)

Gracias a @masaez, que me invitó al evento, en el Track 4 (16:35), Sala Arquitectura, daré una charla sobre Intérpretes y Compiladores en .NET. Los que me leen por aquí, saben que es uno de mis temas preferidos: construir lenguajes con distintos paradigmas de programación, y para usarlos en proyectos (como AjBasic en AjGenesis). La charla es de 75 minutos, con preguntas y respuestas.

Mi idea es visitar temas como:

- Cómo construir un Intérprete, con pasos en detalle, usando TDD.
- Tokens, Lexer, Parser, Expresiones, Comandos
- Ejemplos de intérpretes, de distintos tipos de lenguajes, como AjSharp, AjTalk (bytecodes a la Smalltalk), AjLisp (más funcional), o AjIo, tendré que elegir algunos.
- Comentar los lenguajes que han sido portados a .NET
- Descubrir IL (Intermediate Language) y generar código desde nuestros programas
- Ejemplo de AST (Abstract Syntax Tree)
- La aparición de los lambda. Compilación de Expressions
- Compilación dinámica de expressions
- Dynamic Runtime Library, ejemplos de lenguajes implementados
- Y espero transmitir algo de ¿por qué más lenguajes?

Como siempre, el código, enlace, presentación que prepare, quedaran aquí publicados en próximo post.

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

Generación de Código, AjGenesis y AjBasic

lopez — Mon, 15 Jun 2009 16:09:00 GMT

En el post que comenté ayer

Sobre la generación de código

el comentador Emmanuel escribía:

Pregunta: Ya que tu apodo es "java" :), porque no utilizar StringTemplate en vez de crear tu propio generador?

http://www.stringtemplate.org/

http://antlr.org/about.html

La respuesta es corta y es larga. Si vieron los ejemplos que he publicado, y cómo funciona AjGenesis:

AjGenesis (posts en español con ejemplos)

sabrán que he implementado mi propio lenguaje interpretado AjBasic (con una implementación ahora separada en http://code.google.com/p/ajbasic/), que ahora está evolucionando a ser un lenguaje, con el mismo núcleo que el AjSharp:

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

También está pensado que se pueda utilizar otro lenguaje para los templates:

Escribiendo templates de AjGenesis en otros lenguajes

Pero hoy por hoy, se puede usar sólo AjBasic en la generación de código de AjGenesis. Lo adopté, porque pienso que el lenguaje de templates Y DE TAREAS (porque eso tiene AjGenesis, no sólo es templates, sino también contiene código que organiza la generación de artefactos de textos), es tan fundamental en lo que quería construir, que no pensé en montarme sobre otro proyecto. Creo que, pasado el tiempo, ha sido una sabia decisión. Veo que el proyecto actual, tengo un dominio total sobre algo que es parte del núcleo de AjGenesis.

Recordemos que AjBasic se usa en las tareas. Y permite el uso de objetos dinámicos. Por ejemplo:

if not Project.Title then

    Project.Title = Project.Name

end if

if not Project.Version then

    Project.Version = "1.0.*"

end if

Este ejemplo, tomado de una tarea típica de los ejemplos que vienen incluidos con el sistema, muestra dos características muy usadas: una, preguntar por Project.Title y si Project o Project.Title no están definidos, eso vale falso para el if (una extensión de ideas de lenguajes anteriores como PHP). Me evito preguntar por Nothing o cosas así. Y otra característica: como Project es un objeto dinámico, le puedo agregar propiedades en cualquier momento.

También se le pueden sembrar, en el environment (entorno de valores definidos en el sistema en ejecución), objetos .NET “duros”, y el lenguaje los maneja por reflection.

Esto es algo que todo lenguaje interpretado de hoy en día debería tener: explotación fácil y directa de cualquier framework de clases que lo sostenga. He programado AjBasic de tal forma que podría reimplementarlo fácilmente en Java, usando entonces la librería de clases de Java. Y tiene una estructura (intérprete que ejecuta un árbol abstracto), que puede reimplementarse en cualquier lenguaje en que sea necesario. Por ahora, no he visto la necesidad de hacerlo. Estas razones hacen que no me haya preocupado por compilarlo a bytecodes de la máquina virtual, usando CodeDom, o Emit, porque no es el núcleo de lo que estoy persiguiendo: no necesito velocidad, necesito flexibilidad.

Otro pequeño e importante detalle:

include "Tasks/Build${Technology.Programming.Dialect}.ajg"

Este tipo de instrucción, de nuevo inspirado en PHP, permite la inclusión dinámica de código. Dependiendo de lo que diga el modelo de tecnología, puedo incluir en la ejecución a Tasks/BuildCSharp2.ajg o a Tasks/BuildJava.ajg o lo que sea, dinámicamente.

Y en un proyecto actual, del que espero postear en breve, hasta puedo incluir en la expansión de un archivo de template, a otro, dinámicamente:

Imports System

Imports System.Collections.Generic

Imports System.Text

Imports OakLeaf.MM.Main.Business

Imports OakLeaf.MM.Main.Collections

Imports OakLeaf.MM.Main.Data

Partial Public Class ${Table.SqlName}

    ''' <summary>

    ''' Hook method automatically executed from the mmBusinessObject constructor

    ''' </summary>

    ''' <remarks></remarks>

    Protected Overridable Sub HookPartialConstructor()

        '' Place code here to be executed when the business object instantiates

    End Sub

<#

    if System.IO.File.Exists("Templates/${Table.Name}PartialVb.tpl") then

        include("Templates/${Table.Name}PartialVb.tpl")

    end if

#>

End Class

Y tengo más usos para un lenguaje flexible, dentro de AjGenesis. La idea final, es usarlo para tomar decisiones, para convertir el proceso de generación, en un sistema experto. Algunas decisiones ya toma. Por ejemplo, dada un entidad X, que tiene relaciones con otras, puede decidir incluir una página de “ver entidad X” que tenga enlaces o directamente los datos de las entidades con las que se relaciona. O al ver que en el modelo hay entidades, y una de las entidades modela una persona, saber que para mostrar en algun lado (una lista desplegable, una grilla….) a qué persona estamos refiriendo, deberá mostrar nombre, apellido, y tal vez algún de legajo. O que si estoy armando una aplicación distribuida en Java, sepa deducir qué servicios web debo implementar, que DTOs hay que definir, según los casos de usos que estén descriptos en el modelo, y que escriba los ensambladores de esos DTOs.

Esos sos ejemplos pequeños y grandes de decisiones. Pero la idea es ir avanzando en tener más decisiones, y más reglas, implementadas no con un rígido sistema de reglas forward chaining o backward chaining (que no lo descarto, de ahí mi implementación de AjProlog en curso y de otras ideas), sino ir viendo de explorar la inserción de decisiones en cualquier momento del proceso de generación de código.

Otro ejemplo: en el proyecto en curso, un sistema real, se implementó con AjBasic/AjGenesis una serie de reglas que examinan la base de datos de desarrollo, y detectan inconsistencias en los nombres de las columnas o relaciones de uno a muchos mal definidas. Y podemos seguir implementando más reglas, que nos avisen de otros problemas.

Por todo esto, es que no adopté un lenguaje de templates existente: AjGenesis necesitaba, desde su concepción, un lenguaje que fuera más que un lenguaje de templates. Esto me lo hizo ver mis primeros trabajos en el tema, en los 80, cuando implementé algo parecido en C, pero con limitaciones. Y cuando leí en estos años, el libro de Kathleen Dollard Code Generation in Microsoft .NET donde ella no se animaba a implementar un lenguaje, y adoptaba uno existente, como XSLT sobre XML (mala elección), y luego en cada capítulo, tenía que hacer malabares con el modelo, para poder conseguir algún resultado, al leer eso, me decidí por un lenguaje flexible.

Y no tardé mucho en construir el prototipo. Resultó, como muchas otras veces, divertido! :-)

Nos leemos!

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

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

lopez — Fri, 26 Sep 2008 11:57:17 GMT

El pasado mes publiqué un proyecto en Google code:

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

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

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

La solución

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

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

printline "Hello World";

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

Como mencionaba en mis anteriores posts:

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

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

Podemos escribir código en AjSharp como:

a.FirstName = “Adam“;

a.LastName = “Doe“;

a.Age = 800;

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

Podemos preguntar por la existencia de una propiedad:

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

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

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

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

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

El intérprete

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

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

Los tests

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

Consola y GUI

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

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

Trabajo en progreso

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

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

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

- Soporte para System.Array en ambos intérpretes

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

- Operadores de incremento y decremento

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

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

Nos leemos!

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

AjBasic: un intérprete Basic de código abierto

lopez — Wed, 20 Aug 2008 10:59:50 GMT

Mi proyecto de generación de código AjGenesis usa un lenguaje interpretado para ejecutar tareas y expandir plantillas. El lenguaje fue bautizado AjBasic. Lo puede ver usado en todos los ejemplos que escribí para AjGenesis (más información en los posts de AjGenesis). Hace unos años, había separado el códgio del intérprete del proyecto madre, pero nunca lo había publicado. Este fin de semana, estuve refactorizando el código, y ahora, el resultado de ese trabajo está publicado en:

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

En mi opinión, Google Code es fácil de manejar. Al contrario de SourceForge y CodePlex, usa Subversion como repositorio de código. Uso el cliente Tortoise SVN para enviar los cambios. La gente de Google es gentil: pude crear varios proyectos, por ahora esta es la lista:

http://code.google.com/p/ajlisp (en buena forma, se pude comenzar a investigar)
http://code.google.com/p/ajtalk (todavía en su infancia)

Más información en:

AjLisp- un intérprete Lisp en .NET
AjTalk- un intérprete tipo Smalltalk

La Solución

La solución AjBasicWithTests se compone de los proyectos:

AjBasic: implementa el compilador y el tokenizador. El tokenizer separa el texto entrante en tokens. El compilador arma árboles abstractos a evaluar, desde esa entrada.

AjInterpreter: Un nuevo proyecto, no presente en el AjGenesis original. Contiene toto el soporte del árbol abstracto, sus nodos, el ambiente (environment) donde se almaceman los valores, y un evaluador de los programas. El manejo de objetos .NET, y de objetos dinámicos, están en este proyecto. Mi intención es continuar usando este proyecto para soportar otros lenguajes interpretados.

AjBasic.Console: Una simple consola para probar el intérprete.

AjBasic.GUI: Un simple (y feo) WinForm para probar el intérprete.

AjBasic.Test: Algunos tests, usando NUnit (hay otra solución AjBasic que no incluye el proyecto de tests)

Todos los proyectos están escritos usando Visual Basic .NET. La solución fue compilada usando Visual Studio 2005. La consola y el proyecto GUI podrían ser usados como base, explican cómo usar el intérprete desde nuestra propia aplicación.

Hay varios puntos para discutir sobre la implemetación: merecerian otros posts. Por ahora, exploremos algunas de las principales características del proyecto, en su estado actual. Luego, escribiré una lista de ideas a explorar en futuras versiones.

Como mencioné, el lenguaje nació para soportar la generación de código desde AjGenesis. Yo lo diseñé para manejar objetos .NET nativos, así como objetos dinámicos. Pero ¿qué es un objeto dinámico? Es un objeto que no tiene clase asociada, pero que puede ser expandido con nuevas propiedades (el ejemplo más cercano que podría mencionar ahora, son los objetos Javascript).

Así, podemos escribir código como:

a.FirstName = "Adam"
a.LastName = "Doe"
a.Age = 800

No tenemos que declarar la variable. Podemos crear el objeto y agregar la propiedad FirstName en un comando (esta creación automática de objeto no está soportada en AjGenesis, aún, pero se puede crear un objeto del tipo DynamicObject con new).

Podemos probar la existencia de una propiedad:

if a.LastName then

' it has a LastName not nothing

else

...

end if

Si la variable a no tiene valor asignado, o si no tiene la propiedad LastName, la condición de arriba es evaluada a falso. Podemos preguntar por algo como foo.bar.anything y no se levanta una exception. El valor del resultado sería Nothing, que es evaluado y tomado por falso en una condición.

Los Tests

La solución no fue desarrollado usando TDD (Test-driven development). Escribí los tests despues del código, solo para estar seguro que la funcionalidad principal estuviera bien implementado, cumpliendo con lo que esperaba de cada método. No usé nombres descriptivos para los tests, pero me fueron muy útiles cuando encaré la refactorización de la solución completa:

Podemos probar el lenguaje desde la consola AjBasic.Console:

y desde el WinForm AjBasic.GUI

Ninguno de los dos es la "qué aplicación, que bruta...", pero funcionan.... ;-)

Próximos Pasos

Hay varias ideas volando cerca de la neurona que me queda, y tengo que poner orden en mi cabeza. Algunos puntos, para que queden escritos:

- Ahora que el núcleo del intérprete está separado del compilador basic, me gustaría escribir AjSharp, un intérprete con sintaxis C#. Entonces, podría ser agregado a AjGenesis, para escribir plantillas y tareas en ese lenguaje, que puede resultar más agradable para los programadores C#.

- Agregar soporte de clases dinámicas y prototipos.

- Refactorizar los tests

- Escribir un manual mínimo, explicando el lenguaje y sus características

- Extender el lenguaje para soportar valores "delayed" y "delayed evaluation" (quizás paralelismo).

- La forma internal del intérprete podrías ser reescrita en Java

- La opción de escribir un AST (Abstract Syntax Tree) que se acople al soporte de DLR (Dynamic Language Runtime) no me atrae, podría llevar mucho trabajo. Pero podría ser interesante para aprender sobre el soporte de DLR en .NET.

- Usar el lenguaje como base para la programación de agentees distribuidos (un punto ambicioso, que merece mayor evaluación).

Como es costumbre, me divertí mucho escribiendo este software.

Nos leemos!

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