El miércoles pasado, 22 de noviembre, tuve el gusto de viajar a Bahía Blanca. Nunca había estado en la ciudad y en la zona. Fui a dar una charla sobre .NET 2.0, lo nuevo de ADO.NET 2.0, y en especial ASP.NET 2.0, organizada por el Grupo de Usuarios Microsoft de Argentina. Duró cuatro horas, espero que los asistentes hayan podido disfrutarla, y puedan entender lo que traté de transmitir. Los temas fueron desde el framework de .NET, el concepto de Intermediate Language, la librería de clases, elementos de ADO.NET, y finalmente, jugamos bastante con el tema ASP.NET, investigando el modelo de funcionamiento, el "postback", los controles, los eventos, el enlazamiento a datos. Capítulos especiales de la charla fueron dedicados a los nuevos providers de .NET, para manejo de usuarios y roles, y a las "master pages" y temas.
En Bahía Blanca fui recibido por una socia del MUG, la amable Paola Piovano, que se encarga de organizar la actividad del MUG en la zona. Ya había organizado una charla con el bueno de Carlos Walzer, en el auditorio de la Universidad Tecnológica Nacional. En esta charla mía, colaboró también la gente de la UTN. Conocí al Ing. Guillermo Reggiani que es docente en esa regional. Colaboró junto con sus alumnos para que la charla fuera un éxito. Paola y Guillermo me comentaron que hay pocas actividades de conferencias sobre informática en la región: la regional de UTN de esa ciudad no dicta carreras informáticas. Otra universidad con sede en la ciudad, es la Universidad Nacional del Sur. Ahí sí tienen alguna carrera dedicada a la informática, y al parecer, se dedican a la investigación en inteligencia artificial. Me gustaría saber en que partes de la IA se han interesado.
Conocí también al inefable Marcos Meli, que trabaja en el grupo de Paola, desarrollando para una empresa de la zona. El es el creador de la excelente librería de código abierto:
http://filehelpers.sourceforge.net
http://www.codeproject.com/useritems/filehelpers.asp
Vean el uso de atributos, reflection, generación de clases en ejecución, testing con NUnit, manual. Excelente trabajo, Marcelo!
El material de mi charla lo pueden ver desde:
Material del Seminario .NET 2.0, ASP.NET 2.0, ADO.NET 2.0 en Bahia Blanca
Espero volver ahora en diciembre a esta ciudad, para dar un seminario un poco más extenso, sobre Arquitectura paso a paso en .NET
Aprovecho para agradecerles a Paola, Guillermo, Marcos, y a todos los que colaboraron para que yo pudiera dar esta charla, en especial a Oscar Turquet, del MUG de Argentina, que siempre me hace conocer viajar y conocer a mi pais.
Nos leemos!
Angel "Java" Lopez
http://www.ajlopez.com/
Mi proyecto preferido, AjGenesis, consiste en un generador de código, escrito en VB.NET. Es un proyecto de código abierto, con una licencia tipo BSD, que permite utilizarlo en cualquier proyecto que quieran. Se puede usar como librería, invocado desde nuestro proyecto, se puede invocar desde la línea de comando, o puede ser utilizado desde el poderoso NAnt (esto último me permitió organizar mejor las tareas que realiza el generador de código).
En la página del proyecto (y en el proyecto mismo) hay multitud de ejemplos, que generan código desde un modelo, usando plantillas. Los ejemplos generan código PHP, Java, JSP, VB.NET, C#, ASP.NET, y hasta scripts de base de datos y procedimientos almacenados. Quisiera destacar dos puntos:
- El modelo del que parte es totalmente definible por el usuario
- Las tareas y plantillas a aplicar son totalmente programables y controlables
Esto lo diferencia de otros generadores. Ud. puede hacerse su propio modelo, y sus propias plantillas, para generar los artefactos de texto que prefiera. Otros sistemas parten de la base de datos, y sólo generan un grupo de artefactos de textos predefinidos (por ejemplo, POJOs, o DAOs). Pero con AjGenesis puede generar lo que Ud. quiera.
Para ejemplificar, este artículo se dedica a modelar algo que, si bien no es lo último en tecnología, es la primera prueba que debe pasar un generador de código: modelar y generar un viejo pero entrañable "Hello, World" (programa que encontré por primera vez en el venerable "The C Programming Language" de los buenos de Kernighan y Ritchie).
Los archivos de este ejemplo, pueden bajarse de HelloWorld1.zip
Primero, el modelo. Como menciono en mis charlas, el modelo es una simplificación de la realidad. El modelo, por ejemplo, un mapa, no es la realidad, el territorio. En el caso de los modelos de AjGenesis, se trata de crear inicialmente, un modelo que muestre lo variable de nuestro sistema. En el caso de un HelloWorld, lo que quisierámos modelar como variable, es el mensaje. Entonces, creamos en un directorio de trabajo, el archivo Project.xml:
<Project>
<Message>Hello World, by AjGenesis</Message>
</Project>
Este es el primer paso. Vean que no tuvimos que usar un modelo predefinido, simplemente, lo escribimos en un documento XML bien formado. Nada de schemas, nada DTDs, o bichos raros. Solamente nuestra creatividad.
El segundo paso es elegir la tecnología (lenguaje, plataforma, framework, base de datos), que vamos a utilizar, y escribir (o reutilizar) plantillas. Decidimos crear un ejemplo en VB.NET, un simple programa de consola. La plantilla la escribimos en el archivo HelloVb.tpl
'
' Hello World demo
' generated by AjGenesis
' http://www.ajlopez.com/ajgenesis
'
Module HelloWorld
Public Sub Main()
System.Console.WriteLine("${Project.Message}")
End Sub
End Module
Acá aparece una característica de las plantillas: permiten acceder y utilizar en la salida, los datos del modelo. Al escribir Project.Message entre ${ y }, le indicaros al procesador AjGenesis, que cuando trabaje sobre esta plantilla, reemplace ese texto por el valor de la rama Project/Message en nuestro modelo. Vemos que no usamos una notación XML o XPath para referirnos a algo del modelo. El modelo inicial está serializado en XML, pero AjGenesis lo levanta a memoria, y nos lo deja como un objeto con propiedades.
Hubiéramos podido escribir el modelo como
<Project Message="Hello World, by AjGenesis"/>
El modelo en memoria sería el mismo. Aunque ahora Message está como atributo, para nuestra plantilla sigue siendo la propiedad Message del objeto Project.
Ya tenemos el modelo, y la plantilla. Necesitamos bajar y expandir el AjGenesis-0.4.3.zip (versión en desarrollo, las anteriores versiones están en el directorio de fuentes SourceForge del proyecto). En esa versión, hay un directorio bin con librerías y algún ejecutable. El AjGenesis.Console.exe es el programa que puede invocarse para tomar el modelo y la plantilla, y generar un archivo, así:
AjGenesis.Console Project.xml HelloWorldVb.tpl HelloWorld.vb
Los parámetros se explican así:
Archivo .xml: cuando encuentra en la lista de parámetros un archivo XML, AjGenesis lo carga en su ambiente de variables. El nodo inicial del XML pasa a ser el nombre de la variable que contiene al modelo.
Archivo .tpl: lo toma como plantilla, y lo procesa, generando un archivo con el nombre del siguiente parámetro.
Por supuesto, para que esto funcione, o deberemos poner la ruta completa del ejecutable AjGenesis.Console, o deberemos incluir el directorio bin de AjGenesis en el PATH de nuestro ambiente.
Los parámetros los procesa en orden. Podríamos poner más de un modelo, más de un archivo XML. Por ejemplo, un segundo archivo XML podría describir la tecnología de base de datos a usar, o el nombre de la empresa que está usando el modelo, o cualquier otra cosa que se nos ocurra. Sería conveniente en este caso que el segundo archivo XML tenga un nodo raíz distinto de Project, porque así no sobreescribe al modelo del anterior archivo. También podríamos colocar varios archivos de plantilla con su correspondiente archivo resultado, en una misma invocación.
Si ejecutamos entonces el comando de arriba (necesitamos un framework .NET instalado, recordemos que AjGenesis está escrito en .NET), se genera el archivo HelloWorld.vb
'
' Hello World demo
' generated by AjGenesis
' http://www.ajlopez.com/ajgenesis
'
Module HelloWorld
Public Sub Main()
System.Console.WriteLine("Hello World, by AjGenesis")
End Sub
End Module
No vamos a decir "Uy que bruto..", pero es el primer paso.
Pero vayamos más alla. Supongamos que ahora, con el mismo modelo, queremos generar nuestro gran sistema HelloWorld, en Java. Las presiones del mercado, nuestros clientes, nos piden la nueva versión en el lenguaje multiplataforma Java, y nosotros estamos acá para servirlos. Bien, manos a la obra, creamos un archivo HelloWorldJava.tpl con
/**
* Hello World demo
* generated by AjGenesis
* http://www.ajlopez.com/ajgenesis
*/
public class HelloWorld {
public static void main(String [] args) {
System.out.println("${Project.Message}");
}
}
y ejecutamos en la línea de comando
AjGenesis.Console Project.xml HelloWorldJava.tpl HelloWorld.java
y voilá, se genera el archivo
HelloWorld.java:
/**
* Hello World demo
* generated by AjGenesis
* http://www.ajlopez.com/ajgenesis
*/
public class HelloWorld {
public static void main(String [] args) {
System.out.println("Hello World, by AjGenesis");
}
}
Ya estamos cebados. Vamos por un ejemplo más flexible. Quisiéramos ahora generar el programa VB.NET, el programa C#, el programa Java, y que el nombre de la clase, del programa, sea algo variable (en las plantillas anteriores aparecía siempre HelloWorld como nombre del archivo y de la clase o módulo).
Los archivos de este segundo ejemplo se pueden bajar de HelloWorld2.zip.
Para esto, en otro directorio, creamos el archivo Project.xml con el contenido
<Project>
<Name>HelloWorld</Name>
<Description>Hello World Demostration</Description>
<Message>Hello World, by AjGenesis</Message>
</Project>
Y escribimos las plantillas ModuleVb.tpl
'
' ${Project.Description}
' generated by AjGenesis
' http://www.ajlopez.com/ajgenesis
'
Module ${Project.Name}
Public Sub Main()
System.Console.WriteLine("${Project.Message}")
End Sub
End Module
y ClassJava.tpl
/**
* ${Project.Description}
* generated by AjGenesis
* http://www.ajlopez.com/ajgenesis
*/
public class ${Project.Name} {
public static void main(String [] args) {
System.out.println("${Project.Message}");
}
}
Estudiemos otra característica de AjGenesis: la capacidad de ejecutar un script, en un lenguaje denominado informalmente AjBasic. Creo que esta es una característica poderosa, porque posibilita ir más allá de simplemente la línea de comando. Nos permite manipular programáticamente el modelo y las tareas a realizar. En los ejemplos que encontrarán en la página del proyecto, se usa mucho esta característica, llegándose a producir soluciones completas, con decenas de archivos. Pero veamos nuestro ejemplo.
El programa lo ingresamos en el archivo Build.ajg
PrintLine "Generating ${Project.Name}"
TransformerManager.Transform("ModuleVb.tpl", "${Project.Name}.vb", Environment)
TransformerManager.Transform("ClassJava.tpl","${Project.Name}.java", Environment)
El lenguaje AjBasic, tiene algún verbo predefinido, como el autodescriptivo PrintLine. Notemos que, como en otros lenguajes de scripting, tiene expansión de expresiones en los strings. Esto es, cuando en un texto entre doble comillas (una constante string), ubica una expresión entre ${ y }, la evalúa y la reemplaza por el valor resultante. Muchos de Uds. reconoceran aquí una conducta similar a otros lenguajes de scripting de Unix/Linux, o a PHP, o al Expression Language de JSP 2.x.
La variable TransformerManager es una de las pocas predefinidas. No he definido muchas, y Uds. pueden agregar variables al ambiente de AjGenesis. Pero TransformerManager sirve para invocar programáticamente lo que hacemos desde la línea de comando. Así, el primer parámetro de su método Transform el archivo plantilla, el segundo parámetro es el archivo a generar, y el tercero, la colección de variables definida (en el ejemplo usamos Environment, otra de las variables predefinidas, que justamente es el diccionario de variables que ahora están disponibles en la evaluación de este script).
Ejecutamos lo anterior con
AjGenesis.Console Project.xml Build.ajg
El programa de consola está preparado para ejecutar cada parámetro que tenga la extensión .ajg, interpretándolo como un texto AjBasic.
Pero podemos ir más allá. El año pasado (el proyecto AjGenesis ya lleva sus años en desarollo), incorporé soporte de NAnt. Esto lo hice escribiendo tareas (Tasks) de AjGenesis que pueden invocarse desde ese gran utilitario. Yo uso además, el utilitario NAnt-GUI para ejecutar los archivos .build desde una ventana gráfica.
Escribamos un archivo default.build con el contenido (revise y modifique la property ajgenesis.dir para que refleje el directorio donde ha dejado al AjGenesis):
<?xml version="1.0"?>
<project name="Example 1" default="build">
<property name="ajgenesis.dir" value="c:/ajlopez/dev/AjGenesis-0.4.3"/>
<property name="nanttasks.dir" value="${ajgenesis.dir}/bin"/>
<target name="clean" description="cleans build directory">
<delete dir="${build.dir}" verbose="true" if="${directory::exists(build.dir)}" />
</target>
<target name="loadtasks" description="loads AjGenesis tasks">
<loadtasks assembly="${nanttasks.dir}/AjGenesis.NAnt.dll" />
</target>
<target name="init" depends="loadtasks" description="init the AjGenesis model">
<loadmodel model="Project.xml"/>
</target>
<target name="build" depends="init">
<executetask task="Build.ajg"/>
</target>
</project>
Entonces, desde la línea de comando podemos invocar
nant
Si tenemos configurado a ese utilitario, procesa el target default que de build.xml. Yo uso el NAnt-Gui, que me presenta la pantalla
Espero que este artículo les sirva como inicio de explicación a algunas de las características de AjGenesis. Espero escribir un próximo artículo, con ejemplos de uso de AjBasic dentro de las mismas plantillas, uso más intensivo del NAnt, manipulación del modelo en memoria, y generación de aplicaciones completas, en distintas plataformas y tecnologías.
Si alguien le parece útil, les pido que lo difundan, por ejemplo, con artículo de cómo lo están usando, en su blog.
Gracias por todo, nos leemos!
Angel "Java" Lopez
http://www.ajlopez.com/
El viernes 3 de noviembre pasado, gracias al Grupo de Usuarios Microsoft de Argentina, y en especial, a Oscar Turquet, visité la regional Santa Fé de la Universidad Tecnológica Nacional, en la ciudad del mismo nombre. Con un vista a un lago impresionante, la universidad cuenta con un auditorio que ya había visitado el año pasado. He dejado el material presentado en mi sitio en
http://www.ajlopez.net/ReferenciaVe.php?Id=149
Presenté, como siempre, a mi proyecto de código abierto AjGenesis. Así como presenté mis primeros templates, y las decisiones de diseño que tomé (por ejemplo, abandonando XSLT para las transformaciones, y adoptar un lenguaje de scripting no tipado como el AjBasic), también presenté mis últimos templates, orientados a Domain-Driven Design a la Eric Evans.
Espero que se haya entendido que, más que la generación de código, es importante la presencia de un modelo. A partir de un modelo (que es una simplificación de la realidad), o de varios, podemos generar distintos artefactos de un sistema, y hasta, quizás con el avance de la tecnología, un sistema completo. Mi esperanza está puesta en la generación y refinamiento de modelos, usando algo que podría asimilarse a la inteligencia artificial. Pero si en algo nos puede ayudar el software, es precisamente, en la generación de software.
Me atendieron muy allá, el Dr. Horacio Leone, y el bueno de Iván Melgrati, a quien había conocido el año pasado. Conocí también a Rodrigo Ledesma, que me comentó sobre sus cursos de Java. Muy interesante lo que encontré, por eejemplo, Iván está trabajando en la tecnicatura a distancia en informática, de esa regional, que ya hace un año que está funcionando, y tiene, que recuerde, cerca de doscientos inscriptos.
Estuve preguntando sobre el parque tecnológico de la zona, que parece que va viento en popa. Sin embargo, escasean los profesionales en informática, así como los ingenieros de otras disciplinas duras: hay poca inscripción, pero mucha demanda de las empresas. Al parecer, pocos jóvenes piensan en una carrera tecnológica, o de ciencias, mientras que hay "sobrepoblación" de estudiantes y recibidos en abogacía, administración y otras. Desconozco cuál es la causa, pero espero que las próximas generaciones de mi país retomen el interés por la ciencia y la tecnología, que me parecen fascinantes como actividad humana. Creo fervientemente que si algo perdura, son los avances en ciencia y tecnología. Y que son esos avances los que más influyen (espero que para mejor) en el desarrollo de la historia humana.
Bueno, me puse filosófico, ya comentaré sobre esos temas en mi
blog no técnico, donde discurro sobre filosofía, el sentido de la vida, y bueyes perdidos.
Nos leemos!
Angel "Java" Lopez