PDF de programación - GeneXus y el ciclo de vida de las aplicaciones

GeneXus y el ciclo de vida

de las aplicaciones

Última actualización: Febrero de 2012



GeneXus y el ciclo de vida de las aplicaciones

Copyright  Artech Consultores S. R. L. 1988-2012.

Todos los derechos reservados. Este documento no puede ser reproducido en cualquier medio sin el consentimiento
explícito de Artech Consultores S.R.L. La información contenida en este documento es para uso personal
únicamente.



Marcas Registradas

Artech y GeneXus son marcas o marcas registradas de Artech Consultores S.R.L. Todas las demás marcas
mencionadas en este documento son propiedad de sus respectivos dueños.



Página 1





GeneXus y el ciclo de vida de las aplicaciones

Antecedentes: El viejo paradigma informático ................................................................ 3

GeneXus: un nuevo paradigma .................................................................................... 5

El punto de partida .................................................................................................. 5

El diseño ................................................................................................................ 6

La generación ......................................................................................................... 6

La prototipación ...................................................................................................... 6

El mantenimiento .................................................................................................... 7

La documentación y las ayudas ................................................................................. 7

El trabajo en grupo .................................................................................................. 8

La reutilización del conocimiento (y su eventual comercialización) ................................. 9

Resumen ................................................................................................................... 9



Página 2



GeneXus y el ciclo de vida de las aplicaciones

Antecedentes: El viejo paradigma
informático



Cada vez existen más herramientas que, de alguna manera, pretenden aumentar la
productividad en el desarrollo de aplicaciones.



El esquema original de desarrollo de programas consiste en combinar todas las acciones y
reglas involucradas, organizarlos en un algoritmo y, luego, programar éste en un lenguaje
de bajo nivel. La programación es procedural (o, más propiamente, procedimental).



Las primeras herramientas fueron los llamados “lenguajes de 4a. generación” que, si bien
utilizaban el mismo esquema (procedimental), tenían una fuerte capacidad de expansión de
código lo que permitía escribir mucho menos (y, también, equivocarse mucho menos) para
obtener lo mismo. El impacto de estas herramientas sobre la productividad del desarrollo
fue importante. En cambio, el impacto sobre los costos de mantenimiento fue muy
pequeño: no existe comportamiento inteligente en la herramienta y, como consecuencia, es
imposible un análisis integral del impacto de los cambios en la base de datos sobre los
programas y, mucho menos, la propagación automática de esos cambios.



Otras herramientas importantes lo han sido los generadores de código. En este caso el
sistema “entiende” las especificaciones y, en virtud de ello, genera el programa. Las
primeras versiones eran muy rígidas pero, con el tiempo, se les ha ido agregando lenguajes
procesadores de diagramas de acción (conceptualmente lenguajes procedimentales, muy
semejantes a los lenguajes de 4a. generación).



Estas herramientas ofrecen una alta productividad para el desarrollo (mayor que la de los
lenguajes de 4a. generación).



En lo relativo al mantenimiento, el aporte es pequeño: estas herramientas dependen de la
base de datos (el diagrama E-R suele ser un “input”) y modificaciones en ese diagrama E-R
pueden dejar inválidos múltiples procedimientos. O sea: tampoco aquí existe
comportamiento inteligente de las herramientas y, como consecuencia, el análisis de
impacto de los cambios y su eventual propagación es bastante limitado.



Página 3





GeneXus y el ciclo de vida de las aplicaciones

Si bien no han sido muy importantes (desde el punto de vista de su mercado) existen
también herramientas similares a las anteriores que, en vez de generar código, interpretan
las especificaciones. Esto no cambia nada: cuando una especificación pierde validez por
cambios en la base de datos, el hecho de que se generen programas o se interprete la
propia especificación no hace a lo esencial del problema.



El problema más importante de todos estos tipos de herramientas es que no son capaces de
propagar automáticamente a las especificaciones los cambios sobre la base de datos.
Entonces se usa, con ellas, la hipótesis “la base de datos es estable” y, lamentablemente,
esa hipótesis es falsa.



Problemas semejantes existen con la llamada programación orientada a objetos: cuando se
trata de lógica, incluso muy compleja, pero que no necesita del acceso a la base de datos
(como en el caso de diálogos sofisticados), todo funciona muy bien. Cuando es necesario el
acceso a la base de datos, reaparecen los anteriores problemas.



Página 4



GeneXus y el ciclo de vida de las aplicaciones

GeneXus: un nuevo paradigma

El punto de partida


Se parte de los objetos de los usuarios, que son muy bien conocidos por estos. GeneXus
captura el conocimiento existente en esos objetos y lo sistematiza en una base de
conocimiento.



Lo que GeneXus hace, intrínsecamente, es una muy buena administración automática del
conocimiento. El conocimiento es esencialmente incremental: de una forma incremental
aprendemos y pensamos. La consecuencia más importante de esta muy buena
administración automática del conocimiento es un comportamiento inteligente de GeneXus.



La forma de expresar el conocimiento es muy importante: si somos capaces de expresarlo
en una forma pura, mantiene todas sus características, todo su valor (y, en particular, la
representación de cada objeto depende de ese objeto pero no de la representación de los
demás objetos que puedan interesar al sistema). Este esquema de representación es el
ideal porque, por ejemplo, si necesitamos modificar un objeto, tan sólo debemos modificar
su representación, con total prescindencia de los demás.



Si, en cambio (viejo paradigma), para representar un objeto necesitamos descender a
elementos físicos (como los archivos) la representación pierde mucho poder expresivo con
respecto al conocimiento puro y, en particular, todos los objetos pasan a ser dependientes
de los archivos y, cuando esos archivos cambian, muchas especificaciones se tornan
inválidas y el sistema es incapaz de modificarlas automáticamente para restaurarles la
validez. Como consecuencia, las especificaciones deben estudiarse una a una, lo que
determina los importantes costos de mantenimiento por todos conocidos.



En GeneXus cada objeto se especifica en forma autocontenida sin nunca referirse a archivos
ni a cualquier otro elemento de bajo nivel. Una consecuencia de lo anterior, que será luego
muy importante, es que la base de conocimiento es neutra con relación al ambiente:
arquitectura, hardware, sistema operativo, sistema de gerencia de base de datos, etc.



Página 5





El diseño


GeneXus y el ciclo de vida de las aplicaciones

GeneXus diseña la base de datos y los programas de aplicación. El diseño de la base de
datos es un proceso determinístico: dado un conjunto de objetos del usuario existe una
única base de datos relacional mínima que lo satisface. Luego de muchos años/hombre de
investigación Artech ha conseguido hacerlo automáticamente.



Las bases de datos que diseña GeneXus están en tercera forma normal y tienen los índices
estrictamente necesarios. Sin embargo, a veces, es muy adecuado (por razones de
performance) introducir ciertas redundancias de datos y ciertos índices adicionales.
GeneXus da al analista indicaciones de que redundancias o índices puede ser adecuado
definir y le permite hacerlo y, a partir de ese momento, se hace responsable por su
mantenimiento.

La generación


Partiendo del conocimiento sistematizado GeneXus genera automáticamente la aplicación
(base de datos y programas) para la plataforma que se haya escogido.



Desde un punto de vista lógico, lo que debe hacerse es independiente de la plataforma.
Físicamente, sin embargo, no lo es: cada lenguaje, cada sistema de gerencia de base de
datos, cada sistema operativo, cada arquitectura, tiene comportamientos diferentes.
GeneXus resuelve este problema dividiendo la generación en dos: lógica (la más
importante, la más sofisticada) que es común a todas las plataformas, y física, que se
construye plataforma a plataforma de modo de optimizar los programas generados para
cada una de ellas.

La prototipación


GeneXus genera fácil y rápidamente programas funcionalmente equivalentes para múltiples
plataformas.



Muchas veces las plataformas de ejecución son complejas, costosas o no disponibles en el
momento del análisis. Con GeneXus se genera de inmediato una aplicación funcionalmente
equivalente a la que se está desarrollando que funciona en un PC o, incluso, en un



Página 6



GeneXus y el ciclo de vida de las aplicaciones

“notebook”. Ello permite al usuario probarla de inmediato (lo que probablemente no evita
errores, pero permite detectarlos rápidamente, cuando su corrección es muy fácil).



En vez de escribir en papel copiosas especificaciones, como es habitual y, luego, hacerlas
aprobar por el usuario (que difícilmente las entenderá), se trata de discutir con ese usuario
y mostrarle funcionando el prototipo producto de esa discusión en su propia oficina y muy
rápidamente.



Más allá de las razones técnicas que hacen muy impor