Generación de Código Fuente en Aplicaciones Web.

Universidad de Belgrano
Las
de
tesinas
Belgrano
Facultad de Tecnología Informática
Ingeniería en Informática
Generación de código fuente en aplicaciones
Web.
Nº 226
Leonardo F. Tomé
Tutor: Alejandro A. Vaisman
Departamento de Investigaciones
Agosto 2008
Tesinas
Estilo decisionista matizado de gobierno.
Agradecimientos
“A mi hermano Pablo; a Enrique Molinari y a quienes de una u otra manera ayudaron a que este trabajo sea posible”.
Tesinas
Generación de código fuente en aplicaciones Web.
Tesinas
Generación de código fuente en aplicaciones Web.
Índice
Índice..................................................................................................................................................... 5
Resumen............................................................................................................................................... 7
Capítulo 1 – Introducción...................................................................................................................... 7
1.1 Contexto........................................................................................................................................ 7
1.2 Motivación..................................................................................................................................... 8
1.3 Contribución.................................................................................................................................. 8
1.4 Organización del documento......................................................................................................... 8
Capítulo 2 – Estado del arte.................................................................................................................. 8
2.1 Genexus........................................................................................................................................ 8
Modelo de desarrollo..................................................................................................................... 9
Tecnologías involucradas.............................................................................................................. 9
2.2 BackEnd Wizard.......................................................................................................................... 10
Modelo de desarrollo................................................................................................................... 10
Tecnologías involucradas............................................................................................................ 10
2.3 Otras herramientas...................................................................................................................... 10
ASPRunner Profesional............................................................................................................... 10
SQL2JAVA....................................................................................................................................11
Evolve...........................................................................................................................................11
Brightsword...................................................................................................................................11
2.4 Resumen......................................................................................................................................11
Capítulo 3 – La herramienta propuesta: Balmod..................................................................................11
3.1 Modelo de desarrollo................................................................................................................... 12
Lectura de metadatos.................................................................................................................. 12
Configuración de presentación.................................................................................................... 12
Generación de código................................................................................................................. 12
3.2 Tecnologías involucradas............................................................................................................ 13
3.3 Comparación de Balmod con herramientas similares................................................................. 13
3.4 Resumen..................................................................................................................................... 15
Capítulo 4 – Diseño de Balmod........................................................................................................... 15
4.1 Esquema general de Balmod...................................................................................................... 15
4.2 Técnica de generación “in-line code expansion”......................................................................... 15
4.3 Modelo de datos y procesos........................................................................................................ 16
Lector de Metadatos.................................................................................................................... 16
Generador de Código.................................................................................................................. 17
4.4 Ejemplos de funcionamiento....................................................................................................... 18
Funcionamiento general.............................................................................................................. 18
Generación de código................................................................................................................. 20
4.5 Resumen..................................................................................................................................... 21
Capítulo 5 – Ejemplo de uso............................................................................................................... 21
5.1 Caso de estudio........................................................................................................................... 21
Configuración.............................................................................................................................. 21
Lectura de metadatos.................................................................................................................. 22
Especificación.............................................................................................................................. 22
Generación de código................................................................................................................. 24
5.2 Análisis del código generado con Balmod................................................................................... 26
5.3 Resumen..................................................................................................................................... 27
Capítulo 6 – Trabajos futuros y conclusiones...................................................................................... 27
6.1 Trabajos futuros........................................................................................................................... 27
6.2 Conclusiones............................................................................................................................... 28
Tesinas
Generación de código fuente en aplicaciones Web.
Apéndice A – Ejemplo de una aplicación web..................................................................................... 28
Solicitud de datos al usuario............................................................................................................... 28
Validación de datos ingresados por el usuario.................................................................................... 29
Registro en la base de datos de la información ingresada................................................................. 29
Información del resultado de la operación.......................................................................................... 30
Apéndice B – Configuración de Balmod.............................................................................................. 30
Apéndice C – Conectividad de Balmod con motores de bases de datos............................................ 31
Apéndice D – Componentes Auxiliares............................................................................................... 33
Glosario:.............................................................................................................................................. 33
Bibliografía.......................................................................................................................................... 34
Tesinas
Generación de código fuente en aplicaciones Web.
Resumen
Este trabajo presenta Balmod, una herramienta de software generadora de código fuente orientada al
desarrollo de aplicaciones web que utilicen bases de datos. El principal objetivo de la aplicación consiste
en acelerar el proceso de desarrollo de módulos de uso habitual en diferentes aplicaciones; básicamente
altas, bajas y modificaciones. La generación automática de código fuente permite que las tareas que
habitualmente son realizadas por un programador se realicen automáticamente generando archivos con
código fuente destinado a resolver un determinado tipo de problemas de aparición recurrente. Se logra
así disminuir los recursos de desarrollo necesarios, evitando el origen de errores de programación y
aumentando la productividad.
Una de las características distintivas de la herramienta aquí propuesta es la capacidad de operar independientemente del tipo de tecnología específica que desee utilizarse; ya sea en herramientas relativas
a motores de bases de datos, lenguajes de programación o plataformas de ejecución.
Capítulo 1 – Introducción
1.1 Contexto
Actualmente no existen dudas de que el manejo de información automatizado proporciona beneficios
deseados por cualquier clase de organización como lo son por ejemplo persistencia de información,
búsquedas ágiles y eficientes de información, óptimo mantenimiento de datos y duplicación de datos
instantánea entre otros. Con el desarrollo de internet; la utilidad de los sistemas informáticos se potenció
considerablemente debido a la posibilidad de acceso a la información mediante cualquier computadora
conectada a la red con un navegador (browser) instalado. En sus inicios la totalidad de la información
publicada en internet estaba compuesta por páginas en formato HTML completamente estáticas lo que
no hacía posible personalizar información publicando datos del interés de algún usuario en particular
de acuerdo a las necesidades y/o posibilidades del mismo. Esa fue la causa en la que se originan los
lenguajes de desarrollo de aplicaciones web.
Los lenguajes de desarrollo de aplicaciones web permiten publicar en la red información de manera
dinámica generando páginas HTML mediante el procesamiento de información concreta; esto permite,
por ejemplo, que un usuario se conecte a un sitio web y que solicite información específica, luego el
servidor web recibe esa solicitud, busca la información en alguna fuente de datos (por ejemplo una base
de datos relacional), genera una página HTML que contenga la información solicitada y finalmente envía
la página al usuario. En la figura 1.1 puede observarse un ejemplo tradicional de la arquitectura de una
aplicación web.
Figura 1.1 – Arquitectura de una aplicación web
Tesinas
Generación de código fuente en aplicaciones Web.
El desarrollo de una aplicación web básicamente debe contemplar 3 componentes: un modelo de datos,
una aplicación que envía información al cliente desde el servidor web y finalmente una aplicación que
envíe información al servidor web desde el cliente. Para el modelo de datos mayoritariamente se utiliza
un Sistema Administrador de Base de Datos Relacionales mediante el cual es posible manipular datos de
una manera efectiva y eficiente. La aplicación que envía información al cliente desde el servidor puede ser
implementada utilizando un lenguaje de programación de aplicaciones web como por ejemplo ASP, PHP o
JSP. La aplicación que envía información al servidor desde el cliente puede ser implementada en lenguaje
HTML. Dado que HTML básicamente se trata de un lenguaje orientado a la presentación de información
y no al procesamiento de esta; se extendieron sus capacidades mediante el lenguaje Javascript para tal
fin; para especificar la apariencia de la información presentada se le incluyó el procesamiento de archivos
de estilos denominados CSS (Cascade Style Sheet). En el apéndice A se encuentra un simple ejemplo
de una aplicación web en el que puede observarse como interactúan las tecnologías involucradas.
1.2 Motivación
La aplicación descripta en el apéndice A muestra que son muchas las tecnologías necesarias para
un desarrollo web; esta variedad de tecnologías provoca que la complejidad de un sistema de este tipo
aumente provocando así el incremento de tiempos y costos de desarrollo. En todo proceso de desarrollo de software resulta de gran utilidad identificar previamente tareas recurrentes utilizadas en otros
desarrollos. Considerando que toda aplicación que incluya un repositorio de datos debe proveer una vía
para administrarlo y de acuerdo a la arquitectura expuesta en la figura 1.1 puede inferirse que una de las
tareas presente en desarrollos web es el desarrollo de una aplicación que permita la administración de la
información almacenada en las bases de datos del sistema web. A este tipo de aplicaciones tradicionalmente se los conoce como ABMs debido a que las operaciones básicas propias de la administración de
información almacenada en bases de datos son Altas, Bajas y Modificaciones de datos.
1.3 Contribución
La herramienta aquí presentada permite la generación automática de código fuente para aplicaciones
ABMs independientemente del motor de base de datos de soporte con capacidad de generación en distintos lenguajes orientados a plataformas web. Su utilización permite generar aplicaciones con un esfuerzo
considerablemente menor al necesario en la programación íntegramente manual en cualquier plataforma
de ejecución compatible con Java Virtual Machine.
1.4 Organización del documento
Inicialmente, en el Capítulo 2, serán descriptas herramientas similares a Balmod que reflejan el estado
del arte en el campo de generación de código fuente. En el Capítulo 3 se describirá la funcionalidad de
Balmod y se comparará con las herramientas presentadas anteriormente para establecer las similitudes,
diferencias y contribuciones proporcionadas por cada herramienta focalizándose especialmente en Balmod.
El Capítulo 4 presenta y describe el diseño de Balmod. En el Capítulo 5 se presenta un ejemplo de uso
de Balmod sobre la generación de un ABM del que ya se encuentra desarrollada una versión mediante
programación tradicional. En el capítulo 6 se proponen trabajos futuros y se formulan conclusiones. El
Apéndice A presenta y describe un ejemplo práctico de una aplicación web. Los Apéndices B, C y D contienen información técnica que ejemplifica el funcionamiento de la aplicación.
Capítulo 2 – Estado del arte
En este capítulo se describen las principales herramientas de generación de código existentes. En
particular fueron seleccionadas Genexus y Back End Wizard para estudiarlas en forma detallada.
2.1 Genexus
Genexus es una herramienta desarrollada en Uruguay por ARTech que en 15 años en el mercado tecnológico comercializó más de 15000 licencias brindando servicios a 4500 clientes en 26 países de 4 continentes; su objetivo es asistir al analista y a los usuarios en todo el ciclo de vida de las aplicaciones.
El paradigma de Genexus consiste en automatizar todo lo automatizable, lo que implica en el ciclo
de vida de un sistema informático diseñar automáticamente una base de datos normalizada y generar y
mantener la base de datos, los programas de aplicación y documentación autosuficiente.
Tesinas
Generación de código fuente en aplicaciones Web.
Modelo de desarrollo
El modelo de desarrollo utilizado por Genexus es el modelo de desarrollo incremental basado inicialmente en tres etapas; diseño, prototipación e implementación; posteriormente a la ejecución completa
de estas etapas pueden desarollarse tareas de mantenimiento y de documentación. El ambiente de
realización y prueba de diseño y prototipo utilizado es Windows NT/2000/XP.
En la etapa de diseño el analista junto con el usuario elaboran una base de conocimientos en la que
se incluyen reglas de negocio las cuales se representan mediante diferentes objetos propios de Genexus
como pueden ser por ejemplo el objeto transacción mediante el cual es posible que un usuario pueda crear,
modificar o eliminar información de la base de datos. Una vez finalizada esta etapa puede diseñarse en
forma abstracta (independientemente del motor de bases de datos) un modelo de datos con base en la
teoría de Bases de Datos Relacionales obteniéndose una base de datos en tercera forma normal.
La siguiente etapa es la de prototipación y consiste en probar el modelo diseñado en un prototipo de
Genexus. El prototipo de Genexus es una aplicación completa funcionalmente equivalente a la aplicación
de producción. Durante esta etapa probablemente se detecten fallas en el diseño de la aplicación por lo
que es posible regresar a la etapa anterior para corregir esas fallas.
La tercera y última etapa dentro del modelo de desarrollo es la de implementación la cual se divide en
dos subetapas: especificación y generación. En la subetapa de especificación se determinan tecnologías
y características particulares propias de la tecnología seleccionada. En la subetapa de generación se
produce y compila en código fuente.
Debido a que Genexus utiliza una base de conocimientos para cumplir con su propósito es posible
actualizar aplicaciones actualizando la base de conocimientos. Si se realizan cambios en la base de conocimientos de una aplicación ya implementada Genexus efectúa un análisis de impacto de los cambios
realizados y ofrece la posibilidad de generar programas de conversión para la aplicación implementada
o bien implementar nuevamente toda la aplicación. Debido a esta característica es de suma importancia
no modificar manualmente el código fuente generado por Genexus porque de esta manera se producirían inconsistencias entre la base de conocimientos y la aplicación final lo que puede causar un nivel de
inutilidad absoluto de la funcionalidad de mantenimiento de Genexus.
Durante todo el proceso de desarrollo y mantenimiento de aplicaciones, Genexus elabora y mantiene
un repositorio con documentación acerca de aplicación en cuestión. No solamente incluye la información
propia de la base de conocimientos sino que además incluye toda la información inferida lógicamente.
Tecnologías involucradas
Actualmente existe una gran variedad de posibilidades para generar aplicaciones con Genexus; a
continuación se enumeran todas las tecnologías con las que esta herramienta puede implementar aplicaciones.
Las aplicaciones generadas por Genexus pueden ejecutarse en una gran variedad de plataformas:
· Sistemas operativos:
o IBM OS/400
o Linux
o Uníx
o Windows NT/2000/2003 Servers
o Windows NT/2000.XP/CE
· Plataformas web:
o Java
o ASP.NET
o Visual Basic Script (ASP)
o c/SQL
o HTML
o Web Services
· Plataformas de ejecución:
o JAVA
o Microsoft .NET
Los motores de bases de datos soportados por esta herramienta son:
· IBM DB2 UDB
· Informix
· Miscrosoft SQL Server
· MySQL
Tesinas
Generación de código fuente en aplicaciones Web.
· Oracle
· PostgreSQL.
El código generado puede producirse en los siguientes lenguajes:
· Java
· C#
· C/SQL
· COBOL
· RPG
· Visual Basic
· Embedded Visual Basic
· Visual Fox Pro
Las aplicaciones web pueden ejecutarse en los siguientes servidores:
· Microsoft IIS
· Apache
· Web Sphere
2.2 BackEnd Wizard
El húngaro Attila Zsigmond es el creador de BackEnd Wizard, una herramienta desarrollada unipersonalmente; la última versión de este producto data del año 2004, su principal objetivo es generar páginas
web que permitan listar, buscar, insertar, modificar y eliminar registros en bases de datos.
La herramienta se encuentra implementada en una arquitectura cliente/servidor en lenguaje PHP y si
bien es una herramienta comercial puede utilizarse parcialmente de manera gratuita ingresando a www.
backend-wizard.com .
Modelo de desarrollo
Backend Wizard genera scripts PHP que permiten administrar tablas soportadas en MySQL; su funcionamiento íntegramente basado en una aplicación web consiste en crear las tablas necesarias enviando a
la herramienta los comandos SQL correspondientes, indicar características de presentación de cada uno
de los campos de las tablas en cuestión (por ejemplo, seleccionar si un determinado campo se presentará
como casilla de texto o como lista desplegable) y finalmente generar el script. Una vez que se genera el
script es posible visualizarlo, utilizarlo y testearlo sin costo alguno; si el usuario lo desea puede descargar
el script generado a cambio del pago de una subscripción temporal.
El proceso de creación de scripts resulta ser realmente ágil con el uso de esta herramienta sin embargo Backend Wizard posee dos restricciones sobre el modelo de datos a utilizarse que disminuyen
significativamente su utilidad; la primera restricción es que no recomienda el uso de campos que admitan
valores nulos debido a que pueden generar fallas en la funcionalidad de búsqueda de registros; la segunda restricción establece que todas las tablas del modelo de datos deben poseer como clave primaria
un campo autonumérico, esta restricción impacta significativamente sobre la variedad de modelos de
bases de datos posibles de utilizar ya que restringe la cantidad de campos propios de la clave primaria
impidiendo además que sea posible establecer claves foráneas de más de un campo.
Tecnologías involucradas
Como ya se mencionó anteriormente Backend Wizard genera scripts en código PHP y como motor de
bases de datos utiliza MySQL; actualmente los scripts PHP pueden ejecutarse en servidores web Apache
o Miscrosoft Internet Information Server bajo los sistemas operativos Windows, Linux y Unix. Los scripts
PHP generan información en el servidor Web y la presentan al cliente en lenguaje HTML.
2.3 Otras herramientas
La oferta de herramientas generadoras de código fuente es muy variada. En la página web www.
codegeneration.net puede encontrarse un listado con aproximadamente 200 aplicaciones de este tipo;
cada una posee características particulares que enriquecen o empobrecen su utilidad; a continuación se
describen brevemente algunas de ellas.
ASPRunner Profesional
·
Lenguaje de generación de código: ASP
·
Motores de bases de datos: Oracle, SQL Server, MS Access, DB2, MySQL
10
Tesinas
·
·
·
·
·
Generación de código fuente en aplicaciones Web.
Genera base de datos: no
Plataforma de ejecución: Windows 95/NT o superior
Licencia: comercial
Creador: Universal Data Solutions, Inc (USA)
Pagina web: http://www.xlinesoft.com/asprunnerpro/
SQL2JAVA
· Lenguaje de generación de código: Java
· Motores de bases de datos: Oracle, MYSQL, HSQL y cualquier motor de base de datos que soporte
JDBC
· Genera base de datos: no
· Plataforma de ejecución: compatible con JVM
· Licencia: GPL
· Creador: desarrollo conjunto de código abierto
· Pagina web: http://sql2java.sourceforge.net/
Evolve
· Lenguaje de generación de código: ASP.NET
· Motores de bases de datos: Microsoft SQL Server 2000 o superior
· Genera base de datos: no
· Plataforma de ejecución: Windows 98 o superior
· Licencia: Freeware
· Creador: Joseph Cooney (USA)
· Pagina web: http://www.dcooney.com/evolve/
Brightsword
· Lenguaje de generación de código: ASP, PHP, JSP, ASP.NET
· Motores de bases de datos: Microsoft Access™, MySQL, Oracle y Microsoft SQL Server
· Genera base de datos: no
· Plataforma de ejecución: .NET
· Licencia: comercial
· Creador: BrightSword Technologies Private Limited (India)
· Pagina web: http://www.brightsword.com/
2.4 Resumen
En este capítulo se presentaron herramientas similares a Balmod. Se describieron en detalle Genexus
y Backend Wizard detallando el modelo de desarrollo que utiliza cada una y las tecnologías con las que
trabajan. También se describieron brevemente otras herramientas similares.
En el capítulo 3 se describirá en detalle el modelo de desarrollo y las tecnologías incluidas en Balmod
para luego comparar las tres herramientas descriptas en detalle.
Capítulo 3 – La herramienta propuesta: Balmod
Siempre que se implementa un modelo de datos relacional utilizando un motor de bases de datos es
posible ingresar, modificar y eliminar datos en la base de datos mediante sintaxis SQL. Sin embargo, esta
sintaxis no resulta práctica para el común de los usuarios finales por lo que en la mayoría de los casos
en los que se utiliza una base de datos relacional también debe desarrollarse una aplicación que permita
al usuario final administrar los datos de la base de datos sin que el mismo deba acudir a los tecnicismos
de la sintaxis SQL. A este tipo de aplicaciones se los conoce como ABMs.
Balmod es un software que permite agilizar el proceso de desarrollo de aplicaciones web focalizándose en la generación del código fuente de aplicaciones destinadas a administrar los contenidos de bases
de datos relacionales lo que implica la generación del código fuente de un software que permita realizar
altas, bajas y modificaciones en las diferentes tablas del modelo de datos en cuestión. En otras palabras;
Balmod genera código fuente para ABMs.
Para cumplir con su objetivo Balmod se basa en utilizar la información disponible del modelo de datos;
a la información del modelo de datos (metadatos). El análisis de los metadatos permite deducir el formato
11
Tesinas
Generación de código fuente en aplicaciones Web.
de la información que será almacenada. Por ejemplo; si en el modelo de datos contamos con la tabla
T1 que posee los campos A, B y C siendo A un campo que contiene caracteres, B un campo numérico
y C un campo que almacena fechas es posible inferir que para realizar altas es necesario el ingreso de
una cadena de caracteres, un número y una fecha por lo que automáticamente es posible generar un
formulario que permita dar altas sobre la tabla T1 validando que la información ingresada por el usuario
contenga el formato necesario.
En este capítulo se presenta una descripción general de Balmod y se lo compara con las herramientas
descriptas en el capítulo 2. En el capítulo 4 se describirá detalladamente el producto.
3.1 Modelo de desarrollo
El desarrollo de una aplicación mediante Balmod consta de tres etapas: lectura de metadatos, configuración de presentación y generación de código.
Lectura de metadatos
En esta etapa se indica el modelo de datos que se utilizará junto con información necesaria para
acceder al mismo (usuario de la base de datos, contraseña, etc.); una vez que Balmod se conecta a la
base de datos presenta una lista con las tablas del modelo de datos en la que debe indicarse cuáles
serán administradas mediante la aplicación a generar; posteriormente se procederá a la extracción de
información de cada una de las tablas seleccionadas elaborando internamente un esquema que contempla
características de los diferentes campos de las tablas y sus relaciones. En el Apéndice C se indican los
metadatos requeridos por Balmod para interpretar el modelo de datos.
Balmod considera por cada campo:
· Pertenencia a clave primaria
· Pertenencia a clave foránea
· Tipo de dato
· Tamaño
· Admisión de valores nulos
· Autonumeración del valor
Configuración de presentación
Una vez especificada la información que debe ser considerada para la generación de la aplicación el
usuario tiene la posibilidad de seleccionar diferentes características de presentación de la información a
publicar como por ejemplo la etiqueta de identificación de cada campo y tabla y el modo de selección de
valores de claves foráneas, entre otros.
Generación de código
Finalmente se procede a la generación del código fuente, para ello el usuario debe indicar parámetros
como la ubicación de los archivos generados, datos para la conexión a la base de datos por parte de
la aplicación y ubicación de archivos que pudieran ser referenciados por el código generado como por
ejemplo archivos de imágenes gráficas.
Figura 3.1 – Flujo de datos en Balmod
12
Tesinas
Generación de código fuente en aplicaciones Web.
3.2 Tecnologías involucradas
La actual versión de Balmod está desarrollada con tecnología Java bajo su versión JRE 1.4.2 lo que
permite su ejecución en múltiples plataformas; los parámetros de configuración deben indicarse mediante
lenguaje XML permitiendo una configuración simple, precisa y portable.
Balmod y el código fuente que produce realizan conexiones a bases de datos mediante el uso de objetos
ODBC; actualmente todos los motores de bases de datos utilizados masivamente soportan conexiones
mediante objetos ODBC como es el caso de MS SQL Server, MySQL, PostgreSQL, Informix, IBM DB2
y Oracle. En el apéndice C se detallan las características de conectividad de Balmod con los diferentes
motores de bases de datos.
Balmod genera código fuente en lenguaje PHP, puede ser ejecutado en cualquier servidor web que
soporte esta tecnología como por ejemplo Linux, Uníx, Microsoft Windows, Novell NetWare, OS/2, AS/400
y Solaris. Además, Balmod está diseñado para generar código en lenguajes de desarrollo de aplicaciones
web como por ejemplo ASP y JSP; si bien internamente no implementa métodos que soporten la generación de código en estos lenguajes contiene una especificación para generación de código mediante la
cual es posible implementar métodos que soporten la generación de código en lenguajes ASP y JSP. En
el capítulo 4 se describe el funcionamiento del generador de código de Balmod.
Resumiendo:
· Plataformas de ejecución de la herramienta:
o Cualquiera compatible con JRE 1.4.2 (MS Windows, Linux, Uníx, entre otros)
· Motores de bases de datos soportados:
o Cualquiera compatible con ODBC (MS SQL Server, MySQL, DB2 entre otros)
· Lenguajes del código fuente generado:
o PHP
o Posibilidad de extensión a ASP y JSP.
3.3 Comparación de Balmod con herramientas similares
A continuación se presenta un cuadro comparativo en el que se incluyen características de las tres
herramientas presentadas y descriptas en los capítulos 2 y 3. Las características consideradas son:
· Arquitectura de aplicación generada: indica la disposición física y lógica de los componentes de la
aplicación a ser generada.
· Funcionalidad de las aplicaciones generadas: representa el universo de problemas que la aplicación
generada es capaz de resolver.
· Lenguajes: enumera los lenguajes de programación en los que puede generarse el código fuente.
Solamente son considerados lenguajes de programación web.
· Motores de bases de datos: enumera aquellos motores con los que la herramienta es compatible.
· Plataforma de ejecución: indica la compatibilidad de la herramienta con software de base (sistemas
operativos).
· Generación de modelos de datos: indica si la herramienta genera automáticamente modelos de datos.
Esta característica puede considerarse como una ventaja o una desventaja dependiendo de cada caso
en particular. En aquellos casos en los que no se posea una base de datos generada es un ahorro
de esfuerzo generarla automáticamente. En los casos en los que ya se posea una base de datos
que quiera ser reutilizada en una nueva aplicación la generación automática impediría la reutilización
generando un modelo que probablemente sea diferente al que se desea reutilizar.
· Orientado a modificaciones manuales sobre el código generado: indica si los componentes generados
automáticamente por la herramienta soportan modificaciones manuales. Si la herramienta utilizada
está orientada al programador es porque se pretende que éste perfeccione y/o modifique el código
generado en caso de que sea necesario por lo tanto el código fuente generado debe ser lo más simple, breve y conciso posible para permitir una clara interpretación del mismo; si el programador puede
modificar el código fuente generado con un esfuerzo relativamente bajo tiene la posibilidad de explotar
al máximo las capacidades del lenguaje de programación en cuestión adaptándolo a sus necesidades
particulares. En el caso en el que la herramienta esté orientada al analista lo que debe cambiarse para
perfeccionar una aplicación generada es el modelo lógico de la aplicación (en Genexus el modelo
lógico es la base de conocimientos) y luego se genera nuevamente o se actualiza el código fuente
pero el usuario en ningún momento entra en contacto con el código fuente por lo que no es necesario
que posea conocimientos específicos del lenguaje de programación utilizado
· Restricciones sobre el modelo de datos utilizado: indica si la herramienta es compatible o no con
cualquier modelo de datos.
· Modificación del modelo de aplicaciones generadas: indica si es posible generar nuevas aplicaciones
13
Tesinas
Generación de código fuente en aplicaciones Web.
modificando el modelo de una aplicación generada anteriormente.
· Documentación de la aplicación generada: indica si la herramienta genera algún tipo de documentación
de la aplicación generada.
Genexus
Backend-Wizard
Balmod
Arquitectura de
stand alone y web
aplicaciones generadas
web
web
Funcionalidad de las
general
aplicaciones generadas
ABM
ABM
Lenguajes (web)
Java, ASP.NET, ASP,
c/SQL
PHP
PHP extensible a ASP
y JSP
Motores de bases de
datos
IBM DB2 UDB,
Informix, Miscrosoft
SQL Server, MySQL,
Oracle, PostgreSQL.
My SQL
Cualquiera compatible
con ODBC
Plataforma de
ejecución
MS Windows
Entorno web
Compatible con Java
VM
Genera modelo de
datos
SI
NO
NO
Orientado a
modificaciones
manuales sobre el
código generado
NO
SI
SI
Restricciones sobre el
modelo de datos
--
Claves primarias
simples autonuméricas
Modelo en 3º forma
normal
Modificación del
modelo de aplicaciones
generadas
SI
NO
NO
Documentación de la
aplicación generada
SI
NO
NO
Del cuadro anterior, con respecto a Genexus, se destaca que:
· Es la herramienta más poderosa de las presentadas.
· Su aplicación no se limita solamente a la generación de ABMs orientados a web sino a la generación
de aplicaciones en general.
· Posee una amplia variedad en soporte a bases de datos y los lenguajes de generación de código.
· No genera código en PHP.
· Ejecuta solamente bajo plataforma MS Windows.
· Genera automáticamente el modelo de base de datos. No permite utilizar modelos de datos ya generados.
· No está orientado al programador; sino al analista.
· Soporta la generación de código fuente sobre aplicaciones generadas anteriormente.
· Genera documentación de la aplicación producida.
Con respecto a Backend Wizard se destaca que:
· Su aplicación se limita a la generación de ABMs orientados a web.
· Soporta bases de datos MySQL y genera código fuente en PHP
· Al funcionar en un entorno web puede considerarse que se trata de una herramienta que ejecuta
en cualquier plataforma (si bien la aplicación ejecuta en un servidor un usuario puede acceder a la
herramienta mediante cualquier navegador que se encuentre ejecutándose en cualquier sistema
operativo).
· Utiliza bases de datos existentes. No genera modelos de datos.
· Está orientado al programador.
· Las restricciones sobre el modelo de datos condicionan considerablemente su utilidad.
14
Tesinas
Generación de código fuente en aplicaciones Web.
Con respecto a Balmod se destaca que:
· Posee una amplia variedad en soporte a bases de datos y a lenguajes de desarrollo de aplicaciones
web.
· Es multiplataforma.
· Está orientado al programador.
· Facilidad y rapidez de uso.
3.4 Resumen
En este capítulo se presentó Balmod describiendo su modelo de desarrollo y las tecnologías que utiliza.
También se comparó a Balmod con Backend Wizard y con Genexus destacando las características de
cada una de las herramientas presentadas.
Capítulo 4 – Diseño de Balmod
Tal como se mencionó anteriormente, un ABM posee 3 funciones básicas: altas, bajas y modificaciones.
Las operaciones de altas, bajas y modificaciones implican una serie de procedimientos comunes independientemente del modelo de datos utilizado. Por ejemplo, para realizar una alta en una tabla siempre
deben realizarse como mínimo los siguientes pasos:
· Solicitar los datos a cargar.
· Validar los datos a cargar.
· Cargar los datos en la tabla correspondiente.
· Informar al usuario el resultado de la operación.
Ese tipo de operaciones recurrentes posibilitan la generación automática de código fuente y en base
a estas Balmod cumple con su propósito.
4.1 Esquema general de Balmod
En el capítulo 4 de “Code Generation in Action” ([1]), Jack Herrington propone diferentes técnicas para
generar código fuente. Tomando como referencia teórica esas técnicas Balmod implementa la denominada
“inline code expansion”. La razón de su elección se basa justamente en la similitud de las operaciones
recurrentes mencionadas anteriormente; durante el desarrollo de un ABM se cuenta principalmente con
dos elementos: el modelo de datos y la lógica funcional. El resultado final se logra adaptando la lógica
funcional al modelo de datos y ese es justamente el propósito de la técnica “inline code expansion”.
4.2 Técnica de generación “in-line code expansion”
Esta técnica consiste en tomar una porción de código fuente base y adaptarla a requerimientos específicos. El código fuente base soluciona un problema específico en un entorno general identificando en
su interior aquellos componentes que varían en cada caso particular mediante palabras clave o marcas
especiales en el texto; este podría ser considerado un pseudocódigo. El generador de código debe analizar cada porción de código fuente base para luego modificarla de acuerdo a necesidades específicas
reemplazando las marcas especiales por porciones de texto que se correspondan con los componentes
específicos del caso particular de aplicación.
En el ejemplo expuesto en [1] se presenta una caso en el que se desea generar automáticamente una
porción de código en C++ que retorne en pantalla el resultado de una consulta SQL específica; esto implica
conectarse a la base de datos, preparar la sentencia SQL, ejecutar la consulta, formatear el resultado de
la consulta y mostrarlo en pantalla. Los subprocesos de conexión a la base de datos, ejecución de una
consulta SQL, formateo de resultado de una consulta y presentación en pantalla básicamente realizan
las mismas operaciones en casos diferentes independientemente de la forma de la consulta SQL es por
eso que estos subprocesos pueden incluirse en el código fuente base.
El código fuente base en este caso es:
void main( int argc, char *argv[] )
{
struct {
char *first;
char *last;
} *sql_output_1;
{
15
Tesinas
Generación de código fuente en aplicaciones Web.
db_connection *db = get_connection();
sql_statement *sth = db->prepare( “CONSULTASQL” );
sth->execute();
sql_output_1 = malloc( sizeof( *sql_output_1 )*sth->count());
for( long index = 0; index < sth->count(); index++ )
{
// código para mostrar datos
}
}
return;
}
Los requerimientos específicos en este caso se corresponden con una consulta SQL:
SELECT first, last FROM names
El resultado final es el siguiente:
void main( int argc, char *argv[] )
{
struct {
char *first;
char *last;
} *sql_output_1;
{
db_connection *db = get_connection();
sql_statement *sth = db->prepare( “SELECT first, last FROM names” );
sth->execute();
sql_output_1 = malloc( sizeof( *sql_output_1 )*sth->count());
for( long index = 0; index < sth->count(); index++ )
{
// código para mostrar datos
}
}
return;
}
Nótese que la porción del código base que contenía el texto CONSULTASQL en el código generado
fue reemplazada por SELECT first, last FROM names.
El modelo de Herrington emplea archivos de texto plano como elementos de entrada al proceso de
generación de código lo cual implica que deben ser interpretados mediante un parser; en Balmod tanto
el modelo de datos como las porciones de código fuente base son representadas en clases para evitar el
uso de un parser, obtener valores específicos de una forma más simple y además contar con las ventajas
proporcionadas por el paradigma de programación orientada a objetos es por esa razón que se optó por
Java como lenguaje para su implementación.
4.3 Modelo de datos y procesos
De acuerdo a la técnica “inline code expansion” para la generación del código fuente son necesarios dos
componentes: el código fuente base y los requerimientos específicos. Como ya se mencionó anteriormente,
en el desarrollo de un ABM el código fuente base se corresponde con la lógica funcional y los requerimientos específicos se corresponden con el modelo de datos; estos dos componentes son representados
en Balmod mediante dos módulos; un módulo que permite reconocer e interpretar el modelo de datos
que utiliza una determinada base de datos denominado Lector de Metadatos y un módulo denominado
Generador de Código que basándose en el modelo de datos obtenido genera el código fuente.
Lector de Metadatos
El lector de metadatos a partir de una conexión a una base de datos y de una serie de consultas SQL
genera una colección de objetos que representan metadatos de la base de datos en cuestión.
16
Tesinas
Generación de código fuente en aplicaciones Web.
Figura 4.1 – Entradas y salidas del Lector de Metadatos
El mecanismo es el siguiente:
·
Identifica las consultas SQL necesarias para el motor de base de datos en cuestión.
·
Se conecta a la base de datos.
·
Realiza las consultas correspondientes
·
Genera los objetos correspondientes con los resultados obtenidos
En la figura 4.2 puede observarse en notación UML reducida el diagrama de clases que representa
el modelo de datos; no se incluyen atributos y métodos de cada clase para simplificar el esquema. Los
objetos correspondientes al modelo de datos se corresponden con este diagrama.
Figura 4.2 – Diagrama de clases del modelo de datos
Las clases involucradas son:
· ModeloBDD: contiene la colección de tablas propias de la base de datos en cuestión.
· MetadatosTabla: representa una tabla, contiene una colección de campos.
· Campo: es una clase abstracta que representa el campo de una tabla; contiene atributos comunes a
los campos como el nombre y el tamaño entre otros.
· Tipos de datos: por cada tipo de datos existe una subclase que hereda de la clase Campo. Por ejemplo,
para el tipo de dato entero (habitualmente conocido como int o integer) existe una subclase de Campo
denominada CampoEntero que considera particularidades de este tipo de dato.
· Clave: esta superclase considera restricciones de un campo.
· ClavePrimaria y ClaveForanea: consideran restricciones de clave primaria y clave foránea respectivamente; la relación de composición con un objeto de la clase Clave existe para contemplar casos de
campos que posean restricciones de clave primaria y foránea.
Cada objeto que representa un componente del modelo de datos posee un conjunto de parámetros
que pueden ser editados por el usuario permitiendo personalizar aspectos de la aplicación a generarse.
Por ejemplo, la clase Campo posee un atributo denominado etiqueta mediante el cual el usuario puede
asignar la etiqueta de identificación de cada campo en la aplicación generada.
Generador de Código
El generador de código toma como entradas el modelo de datos representado sobre objetos que
genera el lector de metadatos y una serie de componentes auxiliares (ver Apéndice D) para producir los
archivos de código fuente.
17
Tesinas
Generación de código fuente en aplicaciones Web.
Figura 4.3 – Entradas y salidas del Generador de Código
Su funcionamiento consiste en generar por cada tabla del modelo de datos el grupo de archivos de
código fuente necesario para realizar el ABM de esa tabla. También se encarga de generar archivos de
código fuente de uso general como por ejemplo el menú principal de la aplicación o la librería de conexión
a la base de datos.
En la figura 4.4 puede observarse el diagrama de clases involucradas en el módulo generador de
código.
Figura 4.4 – Diagrama de clases del Generador de Código
Los componentes involucrados son:
· ModeloBDD: explicada anteriormente.
· GeneradorArchivos: se encarga de crear archivos y directorios con el nombre y la ubicación correspondientes. Además, introduce en los archivos el código fuente proporcionado por algún objeto que
implemente la interfaz GeneradorCodigo.
· GeneradorCodigo: establece la interfaz que debe implementar una clase para poder producir código
fuente en Balmod. En la siguiente sección se describe su funcionamiento.
· Generadores: son clases que implementan la interfaz GeneradorCodigo proporcionando código fuente
en un determinado lenguaje de programación.
4.4 Ejemplos de funcionamiento
Funcionamiento general
Se utilizará un ejemplo para aclarar el funcionamiento general de Balmod. Un caso concreto puede
producirse en la elaboración de un sistema de registro de ventas. Es requisito del sistema que para
registrar la venta de un artículo debe ingresarse un registro en la tabla VENTAS; la cual contiene los
siguientes campos:
· artículo: campo de texto que registra el artículo vendido.
· monto: campo numérico que refleja el monto de la venta.
· fecha: campo que almacena la fecha en la que ocurrió la venta.
El modelo de datos está compuesto solamente por la tabla VENTAS; recopilando información sobre
18
Tesinas
Generación de código fuente en aplicaciones Web.
esta tabla estaremos en conocimiento de los requerimientos específicos de la aplicación. Una vez que
el Lector de Metadatos interpreta la información del modelo de datos obtiene el siguiente diagrama de
objetos:
Figura 4.5 – Diagrama de objetos
El diagrama representa a la tabla VENTAS y a los tres campos que la conforman; cada campo es un
objeto perteneciente a una clase representante de un tipo de dato particular, en este caso existen instancias de las clases CampoTexto, CampoNumero y CampoFecha.
Por otra parte tenemos conocimiento de la lógica funcional de un ABM; ésta debe contemplar:
· Formularios de carga de datos.
· Validación de los datos cargados y posterior registro según corresponda.
· Listados de datos cargados.
· Mecanismos para baja y modificación de datos.
Los componentes de la lógica funcional de un ABM se corresponden con los métodos contenidos en
la interfaz GeneradorCodigo. Así, por ejemplo, en la elaboración de un formulario para la carga de datos
se dispone de un método que recibe como parámetro la tabla en cuestión y de acuerdo a la naturaleza
de cada uno de los campos de la tabla genera el código correspondiente; si el campo es un número genera el código necesario para permitir el ingreso de números, si el campo es una fecha genera el código
necesario para permitir el ingreso de una fecha y así sucesivamente. El pseudocódigo básico del método
mencionado es el siguiente:
funcion generarFormulario (MetadatosTabla mt)
por cada campo c existente en mt
imprimir (campo c)
fin loop
fin funcion
El método imprimir(campo c) se ejecuta de acuerdo a la naturaleza del campo en cuestión. Cada tipo
de dato contiene una implementación particular de este método, no es igual el código correspondiente
a un campo numérico que el correspondiente a un campo de fecha. La aplicación determina en tiempo
de ejecución - utilizando polimofirsmo - cual de todos los métodos ejecutar de acuerdo al tipo de objeto
instanciado por el Lector de Metadatos.
Si se une la lógica funcional general de un ABM junto con los requerimientos específicos particulares
de la aplicación es posible determinar concretamente la lógica funcional para la aplicación particular. La
misma en este caso sería:
· Presentar un formulario para registrar ventas. El formulario debe permitir la carga de un artículo, el
precio y la fecha correspondientes.
· Evaluar que la información ingresada por el usuario se encuentre en el formato correcto. Es decir, que
el campo artículo esté completado con una cadena de caracteres, que el campo precio contenga un
número y que el campo fecha contenga una fecha válida. Si los datos son correctos debe procederse
al registro de la venta, caso contrario deberá indicársele al usuario que dato debe corregir y como
hacerlo.
· Presentar al usuario un listado de las ventas registradas.
· Proveer las herramientas necesarias para que el usuario pueda eliminar o modificar las ventas en las
que detecte algún error en la información registrada.
19
Tesinas
Generación de código fuente en aplicaciones Web.
Generación de código
El módulo de generación de código fuente en Balmod consiste en la implementación de una interfase
en lenguaje Java denominada GeneradorCodigo; en esta interfase se incluyen los prototipos de una lista
de métodos mediante los cuales es posible indicar la manera en la que un lenguaje en particular realiza
una operación; todos los métodos retornan una cadena de caracteres o un conjunto de cadenas de caracteres y la gran mayoría recibe como argumento uno o varios objetos que representan componentes
del modelo de datos como por ejemplo tablas, campos y claves primarias entre otros.
Balmod incluye una implementación de la interfase GeneradorCodigo mediante la clase GeneradorCodigoPHP de la cual a continuación se expone la implementación de uno de los métodos propios de
la interfase en el que se retorna un conjunto de cadenas de caracteres que contienen el código PHP
necesario para conectarse a una base de datos.
public ArrayList conexionBaseDeDatos() {
ArrayList codigo = new ArrayList();
codigo.add(“<?php”);
codigo.add(“// Conexión a la base”);
codigo.add(“include(\”../includes/conexionODBC.php\”);”);
codigo.add(“// Objeto de la base de datos”);
codigo.add(“$baseDeDatos = new baseODBC();”);
codigo.add(“$link_id = $baseDeDatos->conectar() or die(\”Se produjo el siguiente error al intentar
conectarse a la base de datos:\” . $baseDeDatos->sqlError());”);
codigo.add(“?>”);
return codigo;
}
A continuación se presenta otro ejemplo de implementación de un método de la interfase GeneradorCodigo en el que se genera el código PHP para imprimir en formato HTML una lista de selección de
valores correspondientes a una clave foránea compuesta por un campo (ClaveForaneaSimple); nótese
que en este caso el método recibe como argumento un objeto que representa una clave foránea.
public ArrayList imprimirSelectClaveForaneaCombo(ClaveForaneaSimple cf) {
ArrayList codigo = new ArrayList();
String[] campos_a_mostrar = cf.getParametrosEditables().ArregloDeColumnas();
codigo.add(“<TR>” + this.etiquetaCampo(cf.campo) + “<TD>”);
codigo.add(“<SELECT name=\”” + cf.campo.nombreEtiquetaHTML() + “\”>”);
codigo.add(“<?php”);
codigo.add(“//rellenado del SELECT”);
codigo.add(“$resultado = $baseDeDatos->comandoSQL(\”select “ +
cf.getColumnaForanea() + “,” +
MetodosAuxiliares.unirStrings(campos_a_mostrar, “, “) + “ from “ +
cf.getNombreTablaForanea() + “\”) or die(\”</select>Se produjo el siguiente error al intentar
realizar una consulta a la base de datos:\”. $baseDeDatos->sqlError());”);
codigo.add(“while ($linea = $baseDeDatos->generarLinea($resultado))”);
codigo.add(“\techo \”<option value=$linea[“ + cf.getColumnaForanea() +
“]>$linea[“ + MetodosAuxiliares.unirStrings(campos_a_mostrar, “] - $linea[“) +
“]</option>\”;”);
codigo.add(“\t$baseDeDatos->liberarRecordset($resultado)”);
codigo.add(“?>”);
codigo.add(“</SELECT>”);
codigo.add(“</TD></TR>”);
return codigo;
}
La interfase GeneradorCodigo está compuesta por 50 métodos y fue diseñada para soportar la
implementación de generadores de código en lenguajes de desarrollo de aplicaciones web por lo que
análogamente a la implementación del generador de código PHP pueden implementarse generadores
para otros lenguajes como por ejemplo JSP o ASP.
20
Tesinas
Generación de código fuente en aplicaciones Web.
4.5 Resumen
El presente capítulo describió como Balmod cumple con su objetivo presentando la técnica “inline
code expansion” y detallando el funcionamiento del Lector de Metadatos y del Generador de Código;
sus dos principales componentes.
Capítulo 5 – Ejemplo de uso
En este capítulo se presenta un ejemplo de uso de Balmod para desarrollar un ABM sobre un modelo
de datos sobre el que ya se encuentra desarrollado otro ABM de manera tradicional. Una vez finalizado
el ejemplo serán comparados los resultados obtenidos desarrollando el ABM mediante la generación de
código manual y mediante la generación de código automática utilizando Balmod.
5.1 Caso de estudio
La aplicación desarrollada manualmente consiste en un ABM de componentes de hardware que permite
administrar un inventario proporcionando información acerca del estado, ubicación y características de
cada componente. Esta aplicación es un caso real desarrollado para el Departamento de Sistemas de la
Universidad de Belgrano en el año 2003. En la figura 5.1 se presenta una porción del modelo relacional
utilizado; para simplificar la presentación de la figura solamente se incluyen seis de los catorce componentes propios del modelo original.
Figura 5.1 – Modelo Relacional
Configuración
Una vez definido el modelo de datos es necesario vincularlo a un origen de datos ODBC; la operatoria de este proceso puede variar dependiendo del sistema operativo utilizado pero en todos los vínculos
21
Tesinas
Generación de código fuente en aplicaciones Web.
ODBC debe indicarse un nombre para la conexión ODBC, un usuario y una contraseña. Con esos tres
parámetros es suficiente para crear un vínculo ODBC, pero ese vínculo representa una conexión a una
instancia de un motor de bases de datos y no a una base de datos específica almacenada en ese motor.
Para un correcto funcionamiento de Balmod es necesario además indicar la base de datos que inicialmente
será utilizada por el vínculo ODBC.
Lectura de metadatos
Al disponer de un vínculo ODBC ya se cuenta con la principal fuente de datos para utilizar Balmod.
En la figura 5.2 puede observarse la primera pantalla que se presenta al iniciar la ejecución de la aplicación; en ella debe indicarse el archivo XML que contiene información de acceso al catálogo de la base de
datos utilizada (en el Apéndice C se describe este tipo de archivos) y los datos del enlace ODBC. En el
presente ejemplo se utiliza un modelo de datos implementado en SQL Server con un componente ODBC
denominado inventario.
Figura 5.2 – Conexión a base de datos
Especificación
El siguiente paso consiste en seleccionar las tablas del modelo de datos para las que se desea generar
el código fuente; la figura 5.3 describe este paso.
22
Tesinas
Generación de código fuente en aplicaciones Web.
Figura 5.3 - Selección de tablas
Luego puede observarse la estructura de cada tabla seleccionada en el paso anterior tal como puede
apreciarse en la figura 5.4 en la que se presenta la composición de la tabla dispositivos. En esta pantalla
también es posible definir el texto (etiqueta) mediante el cual se identificará a la tabla en cuestión en los
títulos e identificadores del código generado y por cada campo de la tabla puede indicarse si el mismo
será incluido en los listados de presentación de los datos cargados en el código generado.
Figura 5.4 - Detalle de tablas
23
Tesinas
Generación de código fuente en aplicaciones Web.
También es posible visualizar y configurar información específica de cada campo. En la figura 5.5 se observa el detalle del campo idubicacion de la tabla dispositivos; en este caso es posible indicar la etiqueta de
identificación del campo (como en todos los campos) y al tratarse de un campo que forma parte de una clave
foránea también pueden indicarse formas de selección de los valores almacenados en las tablas referenciadas por la clave foránea durante una operación de alta o modificación. De acuerdo a la configuración indicada
en la figura 5.5 la etiqueta para el campo idubicacion de la tabla dispositivos será ubicación de dispositivos y
la selección de los valores almacenados en tablas referenciadas por claves foráneas se realizará mediante
listas desplegables que por cada opción disponible indicarán el sector y la ubicación de la opción en cuestión.
Figura 5.5 - Detalle de campo
Generación de código
Finalizada la configuración de la presentación y el funcionamiento de las tablas y campos solamente
restan indicar unos pocos parámetros antes de generar el código fuente. Como puede observarse en la
figura 5.6 los parámetros que deben indicarse son los siguientes:
· Parámetros ODBC (ODBC, usuario, password): son parámetros similares a los de la primera pantalla
pero en este caso se especifican aquellos que serán utilizados para conectarse a la base de datos
desde la aplicación web generada.
· Directorio destino: es el directorio en el que se ubicarán los archivos generados.
· Archivos de código fuente: es el directorio en el que se encuentran archivos auxiliares (estos archivos
se describen en el Apéndice D).
· Disposición de marcos (frames): es la disposición en pantalla de los marcos HTML presentados por el
código generado. Es posible colocar el marco con el menú general en el extremo superior de la pantalla
o en el extremo izquierdo de esta. En la figura 5.7 se presenta el cuadro de diálogo desplegado por
esta opción.
24
Tesinas
Generación de código fuente en aplicaciones Web.
Figura 5.6 - Generación de código
Figura 5.7 - Disposición de marcos
Posteriormente se generan los archivos con código fuente mediante el botón generar archivos; Balmod
como mínimo genera cuatro archivos por cada tabla del modelo de datos seleccionada, un archivo administra altas, otro administra modificaciones, un tercero administra bajas y presenta listados y finalmente
el cuarto contiene los marcos HTML incluyendo a los tres archivos anteriores; de acuerdo a parámetros
25
Tesinas
Generación de código fuente en aplicaciones Web.
específicos de cada tabla podrían generarse más archivos, como el caso en el que se opta por definir
valores de claves foráneas mediante un buscador. También se generan archivos de uso global como el
archivo que contiene el menú de opciones o el archivo que contiene información de conexión a la base
de datos. En la figura 5.8 puede observarse la administración de la tabla dispositivos durante la ejecución
de la aplicación generada en el navegador Mozilla Firefox utilizando Microsoft Internet Information Server
como servidor web.
Figura 5.8 - Ejemplo de ABM
5.2 Análisis del código generado con Balmod
En la reproducción del ABM de administración de inventario se generaron automáticamente 138
archivos con código fuente que en total tienen un tamaño de 342 Kbytes (aproximadamente 350.000
caracteres) en 15 minutos; el desarrollo del proyecto original mediante programación manual demandó
aproximadamente 150 horas.
Existen factores que pueden incrementar el tiempo de desarrollo de un ABM con Balmod como por
ejemplo la definición de aspectos estéticos diferentes a los utilizados por defecto pero las operaciones
íntegramente ligadas a la lógica funcional de la aplicación decididamente son menos costosas y más
rápidas de implementar utilizando Balmod en lugar de programarlas manualmente y este tipo de operaciones son recurrentes en cualquier ABM.
La cantidad de archivos generados es directamente proporcional a la cantidad de entidades que se
administrarán mediante el ABM dado que se genera un directorio con al menos cuatro archivos por cada
entidad. El directorio lleva el nombre de la entidad correspondiente. Los archivos generados en cada uno
de estos directorios son:
· alta_[nombre de la entidad].php: contiene el formulario para dar de alta registros de la entidad correspondiente; este formulario se encuentra vinculado a las funciones de validación de los campos y si los
datos ingresados son correctos realiza el registro de datos mediante el archivo listado_[nombre de la
entidad].php.
· modificacion_[nombre de la entidad].php: contiene el formulario para modificar registros de la entidad
correspondiente; este formulario se encuentra vinculado a las funciones de validación de los campos y
si los datos ingresados son correctos realiza la modificación de datos mediante el archivo listado_[nombre de la entidad].php.
· listado_[nombre de la entidad].php: presenta un listado con todos los registros correspondientes
26
Tesinas
Generación de código fuente en aplicaciones Web.
cargados. En este archivo, además, se incluye la funcionalidad para dar de alta registros o realizar
modificaciones de acuerdo a la información recibida de los dos archivos mencionados anteriormente.
También almacena las instrucciones necesarias para dar de baja registros.
· index.html: este archivo es un frameset en lenguaje HTML que contiene los tres archivos mencionados
anteriormente.
Por cada ABM generado, además, se producen una serie de directorios cuya cantidad no varía de
acuerdo a la cantidad de entidades utilizadas que contienen información general para toda la aplicación.
Estos directorios son:
· JS: contiene funciones en lenguaje javascript; principalmente son funciones de validación.
· CSS: contiene hojas de estilo para determinar el aspecto visual de la aplicación.
· IMG: contiene las imágenes utilizadas en la aplicación.
· includes: contiene librerías de uso común en los diferentes componentes de la aplicación como por
ejemplo las librerías con las que la aplicación interactúa con el motor de base de datos.
Finalmente, también son generados 3 archivos independientemente de la cantidad de entidades del
modelo de datos y generales para toda la aplicación:
· index.html: Contiene la página web inicial de la aplicación.
· Encabezado.html: Contiene el menú general de la aplicación.
· Reporte.log: contiene información acerca de los archivos generados automáticamente.
De acuerdo a la estructura de archivos generados el usuario puede realizar modificaciones que afecten
a toda la aplicación o solamente a una parte de esta. Si desea modificar la administración de una entidad
en particular deberá modificar los archivos almacenados en el directorio correspondiente a la entidad
en cuestión. Si desea realizar un cambio general puede hacerlo modificando aquellos archivos que no
se encuentran dentro de un directorio propio de una entidad; es decir, aquellos archivos que contienen
información general para toda la aplicación.
5.3 Resumen
En este capítulo se presentó un ejemplo de uso de Balmod en el que se describen uno a uno los pasos
necesarios para generar un ABM automáticamente.
Capítulo 6 – Trabajos futuros y conclusiones
En este capítulo se mencionan posibilidades acerca de futuros trabajos a realizar tomando como punto
de partida la versión actual de Balmod y se presentan conclusiones finales.
6.1 Trabajos futuros
Balmod fue cuidadosamente diseñado para adaptarse fácilmente futuros cambios; su diseño se ajusta
al uso de patrones de diseño orientado a objetos. Esto se debe a que desde su concepción se propuso
desarrollar una herramienta dinámica que tenga la capacidad de poder adaptarse con el paso del tiempo
a la mayor cantidad de necesidades que pudieran surgir de los diferentes usuarios.
La primera propuesta a trabajos futuros consiste en realizar un estudio estadístico en el que se contemplen cuales son las funcionalidades comúnmente requeridas a sistemas ABM que no sean satisfechas
por Balmod. Una vez clasificadas esas necesidades se tiene un punto de partida para contemplar futuros
cambios en la herramienta.
Basándose en la propuesta anterior pueden surgir cambios que seguramente impactarán en alguno
de los dos principales módulos de Balmod: el lector de metadatos y el generador de código.
Actualmente lector de metadatos reconoce cinco formatos de campos (en el Apéndice C se los
menciona y describe); un futuro cambio podría consistir en ampliar la cantidad de formatos de campos
reconocidos por Balmod.
Con respecto al generador código surge una serie de numerosas posibilidades entre las que se destacan:
· Implementación de generación de código en otros lenguajes de desarrollo de aplicaciones web: actualmente Balmod genera código en lenguaje PHP pero soporta la generación de código fuente en
otros lenguajes similares como ASP y JSP.
· Diseño e implementación de generación de código en cualquier lenguaje de programación: reutilizando
el lector de metadatos utilizado en Balmod existe la posibilidad de generar código en cualquier lenguaje
de programación.
27
Tesinas
Generación de código fuente en aplicaciones Web.
· Diseño e implementación de módulos generadores de consultas a la base de datos: Balmod genera
código fuente para aplicaciones ABMs pero no genera código que pueda utilizarse para realizar consultas específicas sobre el modelo de datos en cuestión; esta sería una funcionalidad de gran utilidad.
6.2 Conclusiones
De acuerdo a lo expuesto en los capítulos anteriores, se concluye en que Balmod es una herramienta
que facilita considerablemente el desarrollo de aplicaciones web que utilizan bases de datos mediante
la reducción de tiempo y esfuerzo de producción, lo que se traduce en decremento de costos. No cuenta
con la totalidad de las posibilidades brindadas por otras herramientas de vanguardia similares (como por
ejemplo Genexus) pero una oferta de posibilidades más reducida implica en este caso mayor facilidad de
uso. Al tratarse de una herramienta que define y acota claramente cual es su fin para el usuario resulta
ser una herramienta de uso simple y rápido. El paso del tiempo y futuras evoluciones de Balmod determinarán si se sacrifica o no practicidad y facilidad de uso a favor de una mayor oferta de posibilidades que
contemplen situaciones o funciones más específicas u orientadas a ámbitos diferentes a la generación
de ABMs.
Apéndice A – Ejemplo de una aplicación web
En una aplicación web la mayor parte de la lógica de negocio se encuentra implementada en el servidor web; éste interactúa con un motor de bases de datos para generar información y presentarla en el
cliente web.
Se tomará como ejemplo una aplicación web que se encargue de insertar registros en una base de
datos. Las funciones que debe cumplir la aplicación son:
· Solicitar datos al usuario.
· Validar los datos ingresados por el usuario.
· Registrar en la base de datos los datos ingresados por el usuario.
· Informar al usuario el resultado de la operación.
Solicitud de datos al usuario
Para esta función se utiliza un archivo HTML; en este caso se lo denominará form.html y su contenido
es el siguiente:
<HTML>
<HEAD>
<TITLE> Alta de registros </TITLE>
</HEAD>
<BODY>
<FORM METHOD=POST ACTION=”alta.php” NAME=”formulario”>
<CENTER>Ingrese el nombre que desea registrar: <INPUT TYPE=”text” NAME=”nombre”><BR>
<INPUT TYPE=”submit” value=”grabar”></CENTER>
</FORM>
</BODY>
</HTML>
El aspecto visual del archivo es el siguiente:
Figura F.1 – Aspecto visual de form.html
En la operación de la aplicación se le presenta al usuario el formulario para ingresar datos y al hacer
clic sobre el botón grabar se procede a registrar el nombre ingresado; la función de registro es realizada
por el código contenido en el archivo alta.php tal como se indica en el parámetro ACTION de la etiqueta
FORM.
28
Tesinas
Generación de código fuente en aplicaciones Web.
La apariencia de la página HTML puede especificarse mediante un archivo CSS; en este caso se utiliza
estilos.css que contiene lo siguiente:
BODY
{
color: red;
}
El código indica que todo el texto que se encuentre dentro de la etiqueta BODY debe ser de color rojo.
Con la siguiente instrucción dentro del código HTML es posible incluir el archivo CSS dentro del archivo HTML:
<link href=”estilos.css” rel=”stylesheet” type=”text/css”>
Validación de datos ingresados por el usuario
En la mayoría de los casos es deseable validar la información ingresada por el usuario para asegurar
que esta cuenta con la forma adecuada. En este caso no se procederá al registro de la información si el
usuario no completa con ningún nombre el casillero correspondiente
Teóricamente este tipo de funcionalidades debería ejecutarse en el servidor web pero en la práctica
por razones de performance es preferible que la ejecución se realice en el cliente para disminuir el procesamiento en el servidor web; recordemos que un servidor web puede estar respondiendo a solicitudes
de múltiples usuarios simultáneamente.
Para validar los datos ingresados se utilizará código Javascript que en este caso se almacena en el
archivo validar.js que contiene lo siguiente:
function validar()
{
if (document.formulario.nombre.value==””)
{
alert(“Debe ingresar un nombre”);
return false;
}
return true;
}
En el archivo form.html deben realizarse alguno ajustes para incluir la funcionalidad proporcionada por
el archivo javascript; su contenido pasa a ser el siguiente (se resalta el código ingresado):
<HTML>
<HEAD>
<TITLE> Alta de registros </TITLE>
</HEAD>
<SCRIPT LANGUAGE=”JavaScript” src=”validar.js”></SCRIPT>
<BODY>
<FORM METHOD=POST ACTION=”alta.php” NAME=”formulario” onsubmit=”return validar()”>
<CENTER>Ingrese el nombre que desea registrar: <INPUT TYPE=”text” NAME=”nombre”><BR>
<INPUT TYPE=”submit” value=”grabar”></CENTER>
</FORM>
</BODY>
</HTML>
Si el usuario no completa el casillero adecuadamente la aplicación no envía información al servidor
web y se advierte al usuario con la leyenda ”Debe ingresar un nombre”.
Registro en la base de datos de la información ingresada
En el caso en el que el usuario complete correctamente el casillero con el nombre a registrar se procederá a la grabación del nombre en la base de datos (en este caso un motor de bases de datos MySQL);
esta operación es realizada por el código fuente PHP almacenado en el archivo alta.php que debe ubicarse
en el servidor web y contiene lo siguiente:
<?php
var $conexion;
$conexion = mysql_connect(“host”,”usuario”,”password”);
mysql_query(“insert into nombres values(‘$_POST[nombre]’)”, $ conexion);
mysql_close($conexion);
?>
29
Tesinas
Generación de código fuente en aplicaciones Web.
Lo que hace el código es conectarse a la base de datos; realizar la consulta SQL para registrar el
nombre y cerrar la conexión abierta anteriormente.
Información del resultado de la operación
Finalmente, es deseable que se le informe al usuario del resultado de la operación realizada; para ello
es necesario incluir código HTML en el archivo que contiene código PHP de la siguiente manera:
<?php
var $conexion;
$conexion = mysql_connect(“host”,”usuario”,”password”);
mysql_query(“insert into nombres values(‘$_POST[nombre]’)”, $conexion) or die(“<H1>Se produjo
un error.</H1>”);
mysql_close($conexion);
?>
<HTML>
<BODY>
<H1>La operación finalizó exitosamente</H1>
</BODY>
<HTML>
El servidor web en ningún momento le envía al cliente código fuente que no sea HTML; de esta manera
en el caso anterior el cliente puede recibir:
<HTML>
<BODY>
<H1>La operación finalizó exitosamente</H1>
</BODY>
<HTML>
O bien puede recibir:
<HTML>
<BODY>
<H1>Se produjo un error.</H1>
</BODY>
</HTML>
Apéndice B – Configuración de Balmod
Previo a la ejecución de la aplicación es necesario configurar una serie de parámetros, algunos son
de vital importancia para el correcto funcionamiento de Balmod.
La configuración general se realiza mediante un archivo en formato XML llamado configuración.xml; la
definición del documento XML se encuentra en el archivo configuración.dtd. Ambos archivos se encuentran
almacenados en el directorio principal de la aplicación.
A continuación se describen cada uno de los parámetros contenidos en el archivo de configuración:
· Pathdestino: ubicación por defecto en la que se creará el directorio con los archivos de código fuente
generado (puede modificarse durante la ejecución del programa).
· Proyecto: nombre del directorio en el que se ubicarán todos los archivos generados.
· Fuentes: ubicación de archivos que deben incluirse dentro de la aplicación web generada (en el Apéndice D se describe la naturaleza de estos archivos).
· MotoresBDD: ubicación donde se encuentran los archivos con información de lectura de los metadatos
de las bases de datos (en el Apéndice C se describen estos archivos)
· DTDs: ubicación donde se encuentran archivos con definición de tipos de datos para documentos XML
(DTD); en este directorio se encuentra el archivo InterfaceBDD.dtd (ver Apéndice C).
· ODBC: nombre por defecto del objeto ODBC (puede modificarse durante la ejecución del programa).
· Usuario: nombre por defecto del usuario con permiso de acceso a la base de datos (puede modificarse
durante la ejecución del programa)
· Password: contraseña por defecto utilizada para acceder a la base de datos con el usuario indicado
en el parámetro anterior (puede modificarse durante la ejecución del programa).
30
Tesinas
Generación de código fuente en aplicaciones Web.
Ejemplo de la información que debe contener un archivo de configuración de Balmod.
<?xml version=”1.0”?>
<!DOCTYPE configuracion SYSTEM “configuracion.dtd”>
<configuracion>
<pathdestino>C:\inetpub\wwwroot\</pathdestino>
<proyecto>generado</proyecto>
<fuentes>d:\archivos autoABM\Archivos fuente</fuentes>
<motoresBDD>D:\archivos autoABM\motores</motoresBDD>
<DTDs>D:\archivos autoABM\DTDs</DTDs>
<ODBC>sis</ODBC>
<usuario>sa</usuario>
<password>123456</password>
</configuracion>
Apéndice C – Conectividad de Balmod con motores de bases de datos
Tanto Balmod como el código que genera efectúan todas las conexiones a bases de datos mediante componentes ODBC lo que garantiza que cualquier motor de bases de datos que cumpla con ese
estándar de acceso funcione sin inconvenientes. Las consultas SQL realizadas por el código generado
por Balmod utilizan el estándar ANSI SQL lo que garantiza que sean interpretadas por cualquier motor
de bases de datos que respete ese estándar. Tanto el estándar ODBC como el estándar ANSI SQL son
implementados por todos los motores de bases de datos que dominan el mercado; por otra parte, la mayoría de los lenguajes de programación (y en particular PHP, ASP y JSP) soportan conectividad mediante
componentes ODBC.
Para que Balmod interprete correctamente los diagramas de datos almacenados en cada base de
datos es necesario indicarle mediante un archivo escrito en lenguaje XML la manera de acceder a la información que contiene la estructura de la base de datos a ser utilizada; tradicionalmente esta información
se encuentra en lo que se denomina catálogo de la base de datos. Por otra parte también es necesario
indicarle en el mismo archivo XML la identificación que utiliza el motor de base de datos en cuestión para
cada tipo de dato correspondiente a un campo de una tabla.
Para conocer la estructura de la base de datos son necesarias las siguientes consultas (el orden de
los datos devueltos por cada consulta debe respetarse):
· Tablas: por cada tabla debe retornar un registro que indique nombre e identificador de cada una de
las tablas de la base de datos.
· Campos: dada una tabla (dentro de la consulta debe indicarse la tabla mediante la constante ##TABLA##, al momento de procesarse la consulta la constante es reemplazada por el valor correspondiente)
por cada campo que contenga debe retornar un registro que indique nombre, identificación, longitud,
admisión de nulos y propiedad de autonumeración del mismo.
· claves_primarias: dada una tabla debe retornar por cada campo perteneciente a la clave primaria un
registro que contenga el identificador correspondiente al campo en cuestión.
· claves_foráneas: dada una tabla debe retornar por cada campo perteneciente a una clave foránea
un registro indicando nombre del campo local, identificador del campo local, identificador de la tabla
foránea, identificador de la columna foránea, nombre de la tabla foránea y nombre de la columna
foránea.
· columnas_tabla_clave_foranea_foranea: dada una tabla retorna por cada campo foráneo a cada una
de los campos foráneos de la tabla dada un registro con el nombre del campo.
· foraneas_inversas: dada una tabla por cada campo que se relaciona como campo foráneo de la tabla
dada retorna un registro que contiene nombre del campo referenciado, identificador del campo referenciado, identificador de la tabla referenciadora, identificador de la columna referenciadora, nombre
de la tabla referenciadora y nombre de la columna referenciadora.
Balmod trabaja con seis tipos de datos diferentes; si en el modelo de datos se utilizara un tipo de datos
no contemplado por Balmod el mismo será ignorado. Para indicar la identificación que utiliza el motor de
base de datos en cuestión para cada tipo de dato se utilizan las instrucciones:
· entero: números enteros
· racional: números racionales
31
Tesinas
Generación de código fuente en aplicaciones Web.
·
·
·
·
cadenacaracteres: cadenas de caracteres de longitud fija.
Cadenacaracteresvariable: cadenas de caracteres de longitud variable.
Fecha: campos de fecha
Booleano: campos booleano (si/no, verdadero/falso, etc.).
No todos los motores de bases de datos permiten el acceso a su catálogo mediante consultas SQL;
un ejemplo son las versiones antiguas del motor de base de datos MySQL (la versión 5.0 de reciente lanzamiento si permite el acceso al catálogo mediante consultas SQL). No obstante con Balmod es posible
ingresar el modelo de datos creando tablas que simulen el catálogo para posteriormente cargarlas con
los datos deseados y posteriormente realizar las consultas SQL sobre esas tablas.
A continuación se presenta un ejemplo con la información que debe contener un archivo de configuración para utilizar el motor de base de datos MS SQL Server.
<?xml version=”1.0”?>
<!DOCTYPE InterfaceBDD SYSTEM “../DTDs/interfaceBDD.dtd”>
<InterfaceBDD motor=”SQLServer”>
<consultas>
<tablas>select name as tabla, id as id from sysobjects where xtype=’u’ and
name!=’dtproperties’ order by name</tablas>
<campos>select c.name,c.colid,t.xtype,c.length,c.isnullable,c.colstat from syscolumns c,
systypes t where t.xtype=c.xtype and c.id=##TABLA## order by colid</campos>
<claves_primarias>select ik.colid, ik.colid from sysobjects o join sysindexes i on i.id=o.
parent_obj and i.name=o.name join sysindexkeys ik on ik.id=o.parent_obj and ik.indid=i.indid where
o.xtype=’PK’ and o.parent_obj=##TABLA##</claves_primarias>
<claves_foraneas>select c.name as columna, c.colid, o.id as idtablaforanea, cf.colid as
idcolumnaforanea, o.name as tablaforanea, cf.name as columnaforanea from sysforeignkeys f join syscolumns c on c.id=f.fkeyid and f.fkey=c.colid join sysobjects o on o.id=f.rkeyid join syscolumns cf on cf.id=f.
rkeyid and f.rkey=cf.colid where f.fkeyid=##TABLA##</claves_foraneas>
<columnas_tabla_clave_foranea>select cf.name, cr.name, o.name from sysobjects
o,syscolumns cf, syscolumns cr, sysforeignkeys f where f.fkeyid=cf.id and f.fkey=cf.colid and f.fkeyid=cr.
id and f.fkey=cr.colid and o.id=f.rkeyid and fkeyid=##FORANEAS##</columnas_tabla_clave_foranea>
<foraneas_inversas>select c.name as columna, c.colid, o.id as idtablareferenciadora,
cf.colid as idcolumnareferenciadora, o.name as tablareferenciadora, cf.name as columnareferenciadora
from sysforeignkeys f join syscolumns c on c.id=f.rkeyid and f.rkey=c.colid join sysobjects o on o.id=f.fkeyid
join syscolumns cf on cf.id=f.fkeyid and f.fkey=cf.colid where f.rkeyid=##TABLA##</foraneas_inversas>
</consultas>
<tipos_campos>
<entero>56</entero>
<racional>62</racional>
<cadenacaracteres>167</cadenacaracteres>
<cadenacaracteresvariable>175</cadenacaracteresvariable>
<fecha>61</fecha>
<booleano>104</booleano>
</tipos_campos>
</InterfaceBDD>
32
Tesinas
Generación de código fuente en aplicaciones Web.
Apéndice D – Componentes Auxiliares
El código fuente producido por Balmod no es generado en su totalidad; existen componentes que son
necesarios y reutilizables prácticamente en cualquier proyecto; por ejemplo, las funciones de validación en
lenguaje Javascript pueden reutilizarse sin sufrir alteraciones, la validación de un número entero solamente
contemplará que el usuario ingrese mediante su teclado uno o varios dígitos y no cualquier otro carácter;
esa validación no debería cambiar su funcionalidad en otros sistemas. A este tipo de componentes se los
denomina componentes auxiliares.
Los componentes auxiliares son archivos que contienen determinada información que en el momento
en el que Balmod genera el código fuente son copiados dentro de directorios propios del proyecto en
construcción.
Existen tres tipos de componentes auxiliares:
· Imágenes: son archivos que contienen imágenes gráficas
· Hojas de estilo: archivos que contienen información de presentación en formato CSS
· Funciones Javascript: archivos que contienen funciones Javascript
Las imágenes deben incluirse dentro de un directorio denominado IMG, las hojas de estilo dentro de
uno denominado CSS y las funciones Javascript dentro de uno denominado JS. Los tres directorios deben
tener la misma ubicación. Balmod implementa los tres tipos de componentes pero el usuario si lo desea
puede modificar la información de éstos para personalizar su aplicación.
Glosario:
· Aplicación Stand Alone (auto soportada): Es una aplicación que –a excepción de software base- no
depende de otras aplicaciones o componentes para funcionar.
· Aplicación web: Es aquella que los usuarios usan desde un servidor web a través de internet o de una
Intranet. Las aplicaciones web son populares debido a la ubicuidad del navegador (browser) como un
cliente. La habilidad para actualizar y mantener aplicaciones web sin distribuir e instalar software en
miles de potenciales clientes es otra razón de su popularidad.
· ASP (Active Server Pages): es un producto de Microsoft lanzado al mercado en 1996; funciona solamente bajo plataformas Windows. Actualmente forma parte de la plataforma de desarrollo .NET
mediante su versión ASP.NET 2.0.
· Base de Datos Relacional: es un modelo de base de datos en la que se especifican relaciones entre
registros de diferentes tablas. Actualmente es el modelo más utilizado para modelar problemas reales
y administrar datos dinámicamente; fue propuesto por Edgar Frank Codd en 1970.
· C++: es un lenguaje de programación diseñado a mediados de los años ochenta por Bjarne Stroustrup
como extensión del lengueje de programación C.
· Catálogo de base de datos: Es un repositorio de información en el que se especifican metadatos de
una base de datos, es decir información específica acerca de la naturaleza de los datos contenidos
en la base de datos.
· Código fuente: es un conjunto de líneas de caracteres que conforman un bloque de texto que genera
un programa mediante un compilador o intérprete para ser ejecutado por una computadora.
· CSS (Cascade Style Sheet – Hojas de Estilo en cascada): es un lenguaje formal usado para definir
la presentación de un documento estructurado escrito en HTML o XML (y por extensión en XHTML).
El W3C (World Wide Web Consortium) es el encargado de formular la especificación de las hojas de
estilo que servirá de estándar para los agentes de usuario o navegadores.
· GPL (General Public License): es una licencia orientada principalmente a los términos de distribución,
modificación y uso de software. Su propósito es declarar que el software cubierto por esta licencia es
software libre.
· HTML (HyperText Markup Language – Lenguaje de Marcas de HiperTexto): es un lenguaje diseñado
para estructurar textos y presentarlos en forma de hipertexto, que es el formato estándar de las páginas
web. Gracias a Internet y a los navegadores como Explorer, Mozilla, Firefox o Netscape, el HTML se ha
convertido en uno de los formatos más populares que existen para la construcción de documentos.
· Javascript: es un lenguaje interpretado orientado a las páginas web, con una sintaxis semejante a la
del lenguaje Java. Fue creado por Brendan Eich en la empresa Netscape Communications. Se utiliza
en páginas web HTML para realizar tareas y operaciones en el marco de la aplicación cliente.
· JDBC (Java Database Connectivity): Es una herramienta mediante la cual es posible realizar opera33
Tesinas
Generación de código fuente en aplicaciones Web.
ciones sobre una base de datos en el lenguaje de programación Java.
· JRE (Java Runtime Environment): es básicamente la máquina virtual de Java sin las herramientas de
desarrollo mediante la cual es posible ejecutar aplicaciones Java.
· JSP (Java Server Pages): es un lenguaje creado por Sun Microsystems a fines de 1999 como adaptación para simplificar el uso de la tecnología de Servlets creada en 1995; existe una equivalencia
entre un servlet y un script JSP pero los scripts JSP son mucho más simples de desarrollar. Tal cual
establece la filosofía de la tecnología Java el lenguaje es multiplataforma; actualmente JSP forma
parte de la plataforma de desarrollo J2EE (Java 2 Enterprise Edition) la cual se encuentra disponible
en versiones comerciales y en versiones de código libre.
· JVM (Java Virtual Machine): La máquina virtual de Java es un programa ejecutable en una plataforma
específica capaz de interpretar y ejecutar instrucciones expresadas en código generado por un compilador del lenguaje Java.
· Marco HTML (Frame): el uso de marcos es una técnica propia del lenguaje HTML mediante la cual es
posible incluir dentro de una página HTML otras páginas HTML.
· Parser: es un analizador sintáctico. Un analizador sintáctico es un programa que reconoce si una o
varias cadenas de caracteres forman parte de un determinado lenguaje.
· PHP (Personal Home Page): fue creado en 1995 por Rasmus Lerdorf quien al corto plazo de haber
creado el lenguaje decidió liberar el código fuente para que cualquiera pudiese utilizarlo, reparar errores
y mejorar el código; de esta manera PHP se convierte en una herramienta de fuente abierta capaz de
operar en diferentes plataformas incluyendo Linux/Uníx, Microsoft Windows, Novell NetWare, OS/2,
AS/400 y Solaris entre otros; actualmente se encuentra en desarrollo la versión 5.0 de esta herramienta.
· Servlet: aplicación escrita en lenguaje Java que se ejecuta en un servidor dentro de una arquitectura
cliente-servidor.
· Tercera Forma Normal: es una propiedad que puede o no cumplir un modelo de datos relacional. El
cumplimiento de esta forma normal garantiza un óptimo mantenimiento de datos, integridad de la
información y evita la redundancia de datos almacenados en una base de datos.
· XML (eXtended Markup Language – Lenguaje de Marcado Extensible): Es un lenguaje sintácticamente
similar a HTML aunque una de las principales funciones con las que nace sería sucederlo, separando
la estructura del contenido y permitiendo el desarrollo de vocabularios modulares, compatibles con
cierta unidad y simplicidad del lenguaje, tiene otras aplicaciones entre las que destaca su uso como
estándar para el intercambio de datos entre diversas aplicaciones o software con lenguajes privados
como en el caso del SOAP.
Bibliografía
· [1] - Code Generation in Action – Jack Herrington – Manning Publications - 2003
· [2] - The desgn Patterns - James W Cooper - Addison-Wesley – 1998
· [3] - Design Patterns: Elements of Reusable Object-Oriented Software – Erich Gamma , Richard Helm,
Ralph Johnson, John Vlissides - Addison-Wesley Professional Computing Series - 1994
· [4] - Documento comercial de Genexus – “Genexus: Visión General “
· [5] - www.genexus.com
· [6] - www.backend-wizard.com
· [7] - www.dofactory.com
· [8] - www.php.net
· [9] - java.sun.com
· [10] - www.abiglime.com/webmaster/articles/asp/122297.htm
· [11] - fenix.dcaa.unam.mx/servidores/docs/bd/ANSI%20SQL.pdf
· [12] - www.wikipedia.org
· [13] - www.webopedia.com
· [14] - www.codegeneration.net
34
Tesinas
Generación de código fuente en aplicaciones Web.
35
Tesinas
36
Generación de código fuente en aplicaciones Web.