Angel "Java" Lopez : AjGenesis, Código Abierto

Modelos para Generación de Código en AjGenesis

lopez — Fri, 12 Mar 2010 10:01:36 GMT

Quisiera hoy enumerar y pasar una corta revista a las opciones que tenemos para escribir, describir un modelo en AjGenesis, mi proyecto open source de generación de códgio.

Una de las ideas básicas de AjGenesis es tener un modelo de libre definición, como punto de partida. No es un modelo fijo. ¿Qué significa esto? Que podemos crear y usar nuestro propio modelo. Veamos un ejemplo concreto. Si quisiéramos modelar una clásica aplicación "Hello, World”, podemos comenzar escribiendo un modelo simple como el siguiente:

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

Y si queremos tener múltiples mensajes, lo extendemos en cualquier momento a:

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

Más información sobre este ejemplo sencillo en A Hello World Application in AjGenesis. (Generando Código: Hello World con AjGenesis).

Pero XML no sólo una de las versiones SERIALIZADAS de un modelo (el modelo es abstracto, AjGenesis lo maneja en memoria, y lo recupera desde donde lo digamos, en las primeras versiones, sólo de XML). En la versión del trunk podemos escribir y usar el modelo serializado como texto:

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

Más información sobre modelos textuales en

Textual Model for Code Generation in AjGenesis
Modelo textual para generación de código con AjGenesis

Si queremos describir una Entidad en una especie de modelo de dominio, podemos escribir algo como este XML de libre formato:

<?xml version="1.0" encoding="ISO-8859-1" standalone="yes"?>
<Entity>
    <Name>Employee</Name>
    <Description>Employee</Description>
    <SetName>Employees</SetName>
    <Descriptor>Employee</Descriptor>
    <SetDescriptor>Employees</SetDescriptor>
    <SqlTable>employees</SqlTable>
    <Properties>
        <Property>
            <Name>Id</Name>
            <Description>Id</Description>
            <Type>Id</Type>
            <SqlType>int</SqlType>
        </Property>
        <Property>
            <Name>EmployeeCode</Name>
            <Description>Code</Description>
            <Type>Text</Type>
            <SqlType>varchar(20)</SqlType>
        </Property>
        <Property>
            <Name>LastName</Name>
            <Description>Last Name</Description>
            <Type>Text</Type>
            <SqlType>varchar(100)</SqlType>
        </Property>
        <Property>
            <Name>FirstName</Name>
            <Description>First Name</Description>
            <Type>Text</Type>
            <SqlType>varchar(100)</SqlType>
        </Property>
        <Property>
            <Name>IdDepartment</Name>
            <Description>Department</Description>
            <Type>IdRef</Type>
            <SqlType>int</SqlType>
            <Reference>Department</Reference>
        </Property>
    </Properties>
</Entity>

Más detalles del uso de un modelo como éste en Application Generation using AjGenesis. (Generando aplicaciones con AjGenesis).

Pero si leer XML nos hace doler los ojos, podemos volver a escribir el mismo modelo en forma textual. El ejemplo de arriba, abreviado:

Entity Employee
    Description = "Employee"
    SetName = "Employees"
    ...
    Properties
        Property Id
            ...
        End Property
            ...
        Property Name
        End Property
    End Properties
End Entity

No lo implementé, pero quiero agregar hojas de cálculo como modelos:

Escribí sobre eso en: Another Model for AjGenesis (Otro modelo para AjGenesis).

Pero a veces, queremos usar algo ya existente como fuente de nuestro modelo. Y con AjGenesis, podemos! Una de las más “populares” fuentes de seudo-modelos es la base de datos misma. En mi opinión, la base de datos no es el modelo ideal, pero, dependiendo del proyecto y de nuestras necesidades, puede ser una solución pragmática (recordemos, AjGenesis y generación de código son soluciones pragmáticas a algunos problemas en el desarrollo de software), así que no dudemos en adoptar fuentes convenientes, sólo hay que estar advertidos de sus limitaciones.

Escribi algún ejemplo en: Generating a Model From the Database Using AjGenesis (Generando un modelo desde la base de datos usando AjGenesis) y en AjGenesis: Generating the Model from the Database (AjGenesis: Modelo desde la base de datos).

AjGenesis nació y fue diseñado para sobrevivir al “fashion development”: no está orientado a una tecnología en particular, a una plataforma, framework, lenguaje determinado. Puede generar cualquier cosa que se un artefacto de texto (y yo diría que más): Java, C#, VB.NET, PHP, archivos de configuración, XML, scripts de base de datos, aún COBOL. Podemos escribir tareas, plantillas y lo que queramos generar, en cualquier momento. Podemos empezar en pequeño, e ir creciendo, agregando más abstraciones y transformaciones. Pero tareas y templates son temas que merecen otro post. Dicho esto, podemos usar como modelo un proyecto complilado. Como ejemplo, escribí sobre el trabajo de Dario Quintana usando .NET y Reflection en at:

AjGenesis: Generating the model from assemblies
AjGenesis: Modelo generado desde los assemblies

En el mundo Java, se acostumbra a generar código desde anotaciones en el propio código (mencionaría como ejemplo al venerable XDocLet). O desde archivos de configuración, la gente de Hibernate tiene hbm2java. NHibernate, la más popular librería open source de Object Relational Mapping en el mundo .NET, no tiene esas herramientas. Como en Java, AjGenesis puede usar los tags meta que se agregab a los archivos de mapeo .hbm, para usarlos en la generación de código. Vean:

Generating Code with AjGenesis using NHibernate Hbm Mapping Files
Generando código con AjGenesis usando archivos de mapeo de NHibernate

(Tengo un ejemplo más completo en el trunk actual, que genera una solución completa en ASP.NET y NHibernate).

Pueden bajarse el proyecto desde el trunk de código en:

http://www.codeplex.com/ajgenesis

Próximos tópicos: tareas, plantillas, abstracciones vs “technicalities”, modelos en memoria, transformaciones modelo a modelo, completando el modelo, tomando decisiones, sistemas expertos e inteligencia artificial aplicada a la generación de código y AjGenesis.

Nos leemos!

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

"Ver la luz" con generación de código y AjGenesis

lopez — Tue, 10 Jun 2008 14:02:59 GMT

Ayer dí una charla gratuita sobre generación de código, usando AjGenesis. Espero haber transmitido la idea de que es más que generación de código, y que va más allá de la tecnología actual.

Quisiera enumerar algunos posts relacionados con el tema, y comentarlos, así como enumerar enlaces y recursos.

Posts sobre generación de código

Sobre la generación de código

Este es el primer post a leer. Vemos ahí que el cambio de tecnología es una constante en la historia de desarrollo de software, y que no se ve en el horizonte una unificación de nada, ni de lenguajes ni de plataformas. Cada año que pasa, sabemos más de hacer sistemas, pero curiosamente, cada sistema nuevo necesita más codigo que el anterior, en general. Aún usando tecnologías que nos alivian el trabajo, por ejemplo, algún ORM (Object Relational Mapper), si la tecnología triunfa, el propio mercado nos lleva a hacer sistemas más complejos y grandes, y lo que ahorramos en código a escribir, luego lo perdemos en la mayor complejidad de lo sistemas que tenemos a nuestro alcance construir.

También se enumeran otras alternativas a la generación de código, y sus problemas. Las herramientas CASE son muy rígidas, o generales o abarcativas, así como UML y otras iniciativas. Lo que necesitamos son modelos específicos de nuestro dominio, y poder generar lo que querramos, de la forma que nos convenga. De ahí la necesidad de contar con un generador de código que no esté orientado a una tecnología a generar en particular, que sea de código abierto, y que genere lo que nosotros le indicamos, no lo que los autores de la herramienta quieren o pensaron inicialmente.

El usar frameworks propietarios, quedarse en una sola tecnología, tratar de generar todo en runtime apelando a metadata, o generar código desde XML aplicando transformaciones XSLT, son alternativas que creo que son inferiores o más complejas, como se explica en ese post.

Generando Código- Hello World con AjGenesis

Esta es la "prueba ácida" de todo generador de código. Si una herramienta de ese tipo no nos ayuda a crear programas "Hola mundo", con variantes, en distintas tecnologías, entonces no es lo bastante flexible. AjGenesis hace hincapié en la flexibilidad, la adaptibilidad a lo que Uds quieran producir, sin atarlos a una forma o metadata en particular.

Generando aplicaciones con AjGenesis

Un post algo viejo, pero que muestra cómo se pueden generar aplicaciones no triviales con esta herramienta.

AjGenesis- Modelo generado desde los assemblies
AjGenesis- Modelo desde la Base de Datos

Posts sobre cómo el modelo puede partir de otras fuentes, cualquiera que Uds. vean que sea conveniente. Luego, la propia herramienta puede mejorar, completar el modelo, hacer inferencias, o Uds. mismos completarlos, por ejemplo, si el modelo de base de datos no es lo bastante rico para darnos algo de semántica sobre el sistema que tenemos entre manos.

Generando código para NHibernate (Parte 3)
Generando código para NHibernate (Parte 2)
Generando código para NHibernate (Parte 1)

Para ver que pueden usar AjGenesis para facilitar el desarrollo usando alguna librería reconocida por la comunidad, pueden leer esta serie de enlaces, donde gracias a una idea de Omar del valle Rodríguez, se desarrollaron templates para usar NHibernate, y generar hasta una capa de presentación web para probar lo generado.

Hacia el AjGenesis Recipes

Es un trabajo en progreso, para incorporar interacción con el usuario durante el proceso de generación de código.

Usando AjGenesis y NAnt

Explicación y enlaces para usar AjGenesis desde NAnt. Si alguien necesita una interfaz gráfica NAnt-GUI, pueden bajarla desde NAnt-GUI (preparado por Carlos Marcelo Santos, del grupo de generación de código)

Genesis Studio- una IDE para AjGenesis

No todo lo tienen que hacer desde la línea de comando, o desde el NAnt/NAnt-GUI. El bueno de Jonathan Cisneros desarrolló esta herramienta WinForm, con sintaxis de color y muchas mejoras en la experiencia de usuario, que pueden bajar desde:

http://www.codeplex.com/ajgenesisstudio

Preservando código en AjGenesis

Si necesitan generar código, pero luego modificarlo, pueden usar algunas capacidades de AjGenesis para delimitar qué parte regenerar y cuales conservan.

Code Generation as a Service

La última adición al AjGenesis: ahora pueden generar código usando una interfaz web. Esto permite que ya sea en Internet, o desde la intranet de su empresa, puedan generar código controlado, que cumpla con los estándares que se hayan adoptado.

Más posts sobre AjGenesis en

AjGenesis

Si necesitan pasarle información a alguien que no maneja el español, pueden probar con mis artículos en "Anglish" (Angel's English):

http://ajlopez.wordpress.com/category/ajgenesis

Enlaces

EL sitio sobre generación de código es

http://www.codegeneration.net

Ahí encontraran comentarios, herramientas, preguntas frecuentes sobre generación de código en general. Tienen una base de datos de herramientas publicadas. Hay enlaces sobre generación de código para distintas tecnologías, como Java, .NET, PHP y también temas de MDA (Model-Driven Architecture).

Otros enlaces que tratamos en las charlas son:

CodeSmith Tools

MyGeneration Software

AndroMDA.org - Home

Mantengo todo tipo de enlaces relativos a generación de código en

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

Lista de correo sobre generación de código

Existe un Google Group que se puede consultar por email, en español, dedicado a la generación de código. Ahí, además de otros temas, se trata de generación de código con AjGenesis, la generación de templates. En los archivos del grupo se publican ejemplos armados por los miembros.

Pueden ver los mensajes y suscribirse, en:

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

Conclusión

Espero que quede claro que lo importante es usar generación de código como solución pragmática, pero basado en la abstracción de un modelo. Hacer el ejercicio de abstracción de generar un modelo adecuado para lo que necesitemos, es un "must" que me parece el primer paso para separarnos de los problemas de cambios en las tecnologías, herramientas y plataformas.

Luego, el modelo debe ser de libre definición. Y el texto o código generado, también: debe ser el tipo de texto o código que hubiéramos generado nosotros mismos. Finalmente, la herramienta de generación de código tiene que estar disponible en código totalmente abierto, para que se pueda extender, entender o usar de la forma que querramos.

Tengo que escribir más sobre la importancia del modelo, y que pueden hacer el suyo propio: no hay modelo fijo, pueden partir desde la base de datos, desde los archivos XML de los ejemplos, o desde donde quieran. También tengo que escribir sobre la posibilidad de hacer modelos que se deriven de otros modelos. Y escribir haciendo énfasis en que lo que construimos, en realidad, es un sistema experto. De ahí, que desde el principio, incorporé un lenguaje de programación que puede tomar decisiones, completar y modificar el modelo.

Como ven, con AjGenesis, ¡sky is the limit! :-)

Nos leemos!

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

AjGenesis: Modelo desde la Base de Datos

lopez — Sun, 25 Nov 2007 15:15:29 GMT

AjGenesis se caracteriza por partir de uno o varios modelos, libres de definición, para generar artefactos de texto, usando tareas y plantillas programables. Cuando inicié el proyecto, recuerdo haber leído el libro de Kathleen Dollard Code Generation in Microsoft .NET

Una de las recomendaciones de la buena de Dollard, es tomar metadata de algún lugar, por ejemplo la base. Como no creo que toda la metadata esté en alguna parte, me incliné desde el principio por un modelo libre (también me aparté rápidamente del camino de Dollard, basado en generar código basado en transformaciones de XSLT, que es el "camino del diablo", no lo intenten en sus casas, sin avisar a sus padres...;-). Hay varios puntos que me interesaron de la postura de Dollard, será cuestión de escribir más adelante un post comentando el libro.

Pero no hay que descartar el tomar metadata, información que nos pueda servir, de otras fuentes, la más común es la base de datos que tengamos entre manos. Recordemos que la generación de código es una solución pragmática, no debemos dejar de usar lo que nos resulte conveniente para el proyecto en el que estemos trabajando.

Así que ya hace unos meses, puse un pequeño ejemplo dentro de los que vienen en el AjGenesis. Pueden verlo en la

AjGenesis Versión 0.5

Está en la carpeta examples\LoadDB.

Trabaja como ejemplo de consulta de esquema contra una base Northwind que tengamos en nuestro MS SQL Server. Desde ese directorio, en una línea de comando, ejecutamos

make

Este comando ejecuta una tarea de AjGenesis:

..\..\bin\AjGenesis.Console Tasks\DbProcess.ajg
pause

Se conecta a la base:

PrintLine "Connection"

AssemblyManager.LoadWithPartialName("System.Data")

con = new System.Data.SqlClient.SqlConnection()

PrintLine "ConnectionString"

con.ConnectionString = "server=(local);uid=sa;database=Northwind"

PrintLine "Command"

cmd = new System.Data.SqlClient.SqlCommand()

cmd.Connection = con
cmd.CommandText = "select * from Information_Schema.Tables"

con.Open()

Uso la información que está en Information_Schema.Tables. Observen el uso del nuevo AssemblyManager, que permite cargar assemblies (tendría que revisar si es necesario cargar el System.Data, y si puedo dejar de usar LoadWithPartialName que ahora en .NET 2.0 está "deprecated")

Luego, consigue los nombres de las tablas:

dr = cmd.ExecuteReader()

TableNames = new System.Collections.ArrayList()

while dr.Read()
    PrintLine "Table " & dr.Item("Table_Name") & ": " & dr.Item("Table_Type")
    TableName = dr.Item("Table_Name")
    if dr.Item("Table_Type")="BASE TABLE" then
        TableNames.Add(TableName)
    end if
end while

dr.Close()

Una vez conseguida esa información, obtiene las columnas de las tablas, armando un modelo en memoria, en una collección Tables:

Tables = new System.Collections.ArrayList()

For each TableName in TableNames
    PrintLine "Loading Table " & TableName
    Table = new AjGenesis.Models.DynamicModel.DynamicObject()
    Table.Name = TableName
    Table.Columns = new System.Collections.ArrayList()

    cmd.CommandText = "SELECT * from Information_Schema.Columns where Table_name='" & TableName & "'"
    dr = cmd.ExecuteReader()

    while dr.Read()
        ColumnName = dr.Item("Column_Name")
        PrintLine "Processing Column " & ColumnName & ": " & dr.Item("Data_Type")
        Column = new AjGenesis.Models.DynamicModel.DynamicObject()
        Column.Name = ColumnName
        Column.DataType = dr.Item("Data_Type")
        if dr.Item("Character_Maximum_Length") then
            Column.Length = dr.Item("Character_Maximum_Length")
            Column.IsNumeric = false
        else
            if dr.Item("Numeric_Precision") then
                Column.Length = dr.Item("Numeric_Precision")
                Column.Scale = dr.Item("Numeric_Scale")
                Column.IsNumeric = true
            end if
        end if
        Column.SqlName = Column.Name
        Column.Name = Column.Name.Replace(" ","")
        Table.Columns.Add(Column)
    end while

    dr.Close()

    Table.SqlName = Table.Name
    Table.Name = Table.Name.Replace(" ","")

    Tables.Add(Table)
end for

Finalmente, hace el viejo truco de recorrer ese modelo, y aplicarle un template, para generar otro modelo (recuerde esta capacidad del proyecto: un modelo puede ser un XML, serializado en archivo de texto, entonces, un proceso de generación puede generar otro modelo para usar o retocar más adelante):

FileManager.CreateDirectory("Model")

for each Table in Tables
    TransformerManager.Transform("Templates\Table.tpl", "Model\${Table.Name}.xml", Environment)
end for

Un ejemplo de modelo generado:

<?xml version="1.0" encoding="ISO-8859-1" standalone="yes"?>
<Table>
    <Name>Region</Name>
    <SqlName>Region</SqlName>

    <Columns>
        <Column>
            <Name>RegionID</Name>
            <SqlName>RegionID</SqlName>
            <DataType>int</DataType>
            <Length></Length>
            <Scale></Scale>
        </Column>
        <Column>
            <Name>RegionDescription</Name>
            <SqlName>RegionDescription</SqlName>
            <DataType>nchar</DataType>
            <Length>50</Length>
            <Scale></Scale>
        </Column>
    </Columns>
</Table>

Ahora, con el AssemblyManager, se podría tomar una .dll cualquiera y cargarla, para usarla en nuestra generación (tengo que postear sobre el uso que le dió el bueno de Darío Quintana a esta "feature", ver Generando con AjGenesis desde los assemblies). Me imagino que podemos usar, por ejemplo, la librería Meta de MyGenerationSoftware para conseguir metadata de cualquier base de datos. Vean también que está disponible el código fuente de ese utilitario.

Nos leemos!

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