¿Qué espero del GX28 Encuentro GeneXus ?

Desde hace unos años por problemas de tiempo y salida en producción de varios proyectos no he podido asistir al evento GeneXus como lo hacía antes. En este GX28 voy a intentar asistir ya que existen varias charlas que coinciden con mis investigaciones actuales.

Dado que hace tiempo que no puedo disfrutar de un Evento GeneXus espero encontrarme con amigos y asistir a charlas que me dejen enganchado como antes. Espero que las charlas no sean muy comerciales y sean técnicas ya que estoy en un punto que necesito saber si GeneXus me acompañara en mi proceso de cambios.

En la actualidad no hay forma de concebir nuestro trabajo sin implementar Integración Continua, Microservicios, Módulos y acercarnos a la cultura DevOps.

En síntesis espero que después de este evento pueda afirmar que GeneXus me acompañara en mi proceso de cambios o el estado en el que se encuentran las herramientas que estoy necesitando.

Revisando un poco la agenda pude ver varias cosas interesantes que como decía coinciden con lo que estoy investigando. Voy a intentar ir a las de DevOps, GXServer  y las de seguridad.

Por ahora mi lista de charlas seleccionadas es la siguiente:

Como implementar módulos en GX y no morir en el intento (Parte 2)

Después de haber sufrido un poco en "mi primer experiencia al intentar modularizar una kb" levante un respaldo y arranque nuevamente a modularizar mi kb.  Los problemas que voy a comentar se presentan por partir de una kb mediana que ya tiene años y el sistema atiende a todo el pais por lo que es algo relativamente importante. (Tengo que lograr que el cambio sea trasparente)

Básicamente me puse a pensar como hacer para modularizar mi kb sin tener que hacer un alto en el desarrollo y sin tener que dedicar mucho tiempo, la realidad es que la kb se encuentra en constante desarollo y en la actualidad tiene tres líneas de desarrollo que implican tocar bastante el código existente.

Necesito lograr comenzar a modularizar "rompiendo" lo menos posible mi kb e ir liberando estos cambios aprovechando el cronograma de trabajo establecido.

Quiero aprovechar las instancias de testing para no tener que volver a probar todo luego de pasar a modulos ya que como todos saben es complejo encontrar el tiempo para hacer grandes cambios y quiero aprovechar los cambios solicitados para poder mejorar el diseño de mi kb.

Aprovechando los tiempos que tengo decidi comenzar a modularizar sin hacer un análisis exaustivo de mi kb si no que arranque por las cosas que rompen los ojos y que son fáciles de pasar a un modulo (Ej. funciones de validación de CI o funciones varias que siempre tenemos en nuestra kb).

Para ilustrar y poder contar lo que hice voy a partir de una kb llamada MiKB. Lo que hice en el día de hoy para comenzar a modularizar y dejar andando mi kb es lo siguiente:

a) Hice una nueva Kb llamada MiKB_CORE: esta kb es la que tendra los modulos que luego voy a usar de MiKB. (Quiero trabajar como si fueran paquetes y tener un diseño de paquetes a futuro)

b) Exporte los objetos que fui seleccionando de MiKB y los importe en MiKB_CORE

c) Hice los módulos según el diseño que quiero implementar en la modularización de la KB. ej. utils, common, mensajes, etc.

d) Pase los objetos a cada Módulo según lo que correspondiera dejando público solo lo que corresponda, por ejemplo las transacciones las puse "Private" ya que desde MiKB quiero que solo vean los procedimientos en cada paquete y no las TRNS (Esto en el arranque).

e) Luego de luchar con algunas cosas que voy a poner en las conclusiones de este post genere un paquete por cada módulo.

f) En mi kb origen (MiKB) cargue estos módulos, al hacer esto los objetos que había exportado ya no están en MiKB y en el código hace referencia a los módulos.

g) En la kb origen (MiKB) borre las trn que pase a módulos en la kb MiKB_CORE

h) Hice "rebuild all" y verifique que todo quedara integrado, por ahora solo hice alguna pruebas unitarias teniendo en cuenta las funcionalidades que pase a los módulos.  Subí todo a GXserver y por ahora todo ha compilado y ha quedado instalado sin problemas.

Conclusiones positivas:

a) Al revisar mi kb pude aprovechar a realizar limpieza de objetos apoyándome en KBDoctor. Con la limpieza y la modularización pude eliminar 20 objetos por estar duplicados o deprecated, aparte de pasar 50 objetos a los módulos.

b) En la kb de los módulos aproveche para mejorar el código de los objetos que importe de la kb origen y pude unificar comportamiento de algunos objetos que tenían mas de 10 años.

c) Pude modularizar y visualizar la potencia de tener todo en módulos, aparte de comenzar con el re-diseño de mi KB después de 10 años de estar metiendo mano de una forma no muy organizada.

El resultado de mi primer etapa de trabajo es la siguiente:

KB CORE con los Módulos                                 

KB que utiliza los Módulos:

En síntesis me encuentro motivado y con ganas de seguir modularizando mi kb  para alcanzar un nuevo nivel de GeneXus Modularity Maturity Model.

Como implementar módulos en GX y no morir en el intento (Parte 1)

Este es mi segundo intento de comenzar a trabajar con módulos en GeneXus y la verdad que mi experiencia no ha sido del todo buena dado que me he topado con algunos bugs que me están enloqueciendo. 

Según el GeneXus Modularity Maturity Model  me encuentro en el nivel 1 (Sin módulos) por lo que estoy intentando comenzar con los módulos pero no dentro de la kb que quiero modularizar, lo que estoy haciendo es tener otra kb en donde creo los módulos y luego trabajo con los módulos en la kb origen. 

Quiero aclarar que trabajando con módulos dentro de la misma kb no tengo problemas mayores pero quiero trabajar con los módulos como si fueran paquetes dado que quiero tener paquetes separados con las cosas que son comunes en varias kbs. 

Mi idea es poder distribuir los jar de cada paquete (modulo gx) en cada aplicación, me encantaría poder hacer un diagrama de paquetes con los diferentes módulos e integrarlos según mis necesidades. 

Esto dado que en la actualidad tengo 5 kbs que tienen objetos comunes y quiero poner esos objetos en un modulo y usar desde las 5 kbs ese modulo. Aparte de querer modularizar una kb grande para que me quede mas sencilla y aprovechar los beneficios de modularizar.

Básicamente en cuanto al trabajo estoy utilizando GX15 U9 y lo que hice fue crear una kb nueva en donde hice un par de módulos, desde la kb origen fue exportando objetos mediante xpz y los importe en la kb donde tenía los módulos.

En la kb de los módulos renombre estos objetos y los organice según mis necesidades, también me quedaron algunas carpetas dentro de mi módulo con el mismo nombre de la kb origen sin sospechar el resultado que iba a obtener al cargar este módulo en mi kb origen.

El resultado que obtuve al cargar el modulo en la kb origen fue el siguiente:

a) Un objeto que exporte de la kb origen llamado PMiObjeto a la kb de módulos en donde lo renombre a miobjeto y al crear el módulo quedo como mimodulo/miobjeto. Al cargar el modulo a la kb origen me cambio el código en toda la kb en donde estaba PMiobjeto.call(....) por mimodulo.miobjeto.call(...). Esto no es un gran problema pero me hubiera gustado poder hacer el cambio en el código a demanda y que no lo hiciera de forma automática dado que al objeto del modulo le había cambiado las rules por lo que tuve que tocar en varios objetos dado que al cambiar el código tuve que cambiar la llamada por el nuevo parámetro. Lo otro que me llamó la atención fue que me borro el objeto PMiObjeto de la kb.  Tengo que admitir que seguramente esto este documentado y sea que yo me lo comí al tirarme a hacer estos cambios dado que si no es así es un bug de GeneXus.

b) Una carpeta que exporte la puse adentro de mi modulo y al cargar el modulo en la kb origen me cambio en todos los objetos (255) que estaban en esa carpeta la propiedad Module/Folder por el nombre que esta adentro del modulo pero que no existe en la estructura de mi kb. Básicamente por la estructura de mi kb no puedo ver esos 255 objetos y al generar quedaron con el nombre del paquete adelante cuando en realidad no corresponde. 

Seguramente lo que esta pasando al exportar un objeto de la kb origen a una kb de modulo y luego cargar el modulo en la kb origen GeneXus deje algúna referencia en el objeto que haga que se tenga este comportamiento. 

Espero que esto sea un bug de GeneXus y que esto se arregle a futuro para no volver a pasar por esto, al día de hoy tuve que levantar una kb de respaldo y estoy haciendo todo nuevamente. 

Dejo estos comentarios para ir compartiendo mis experiencias, de todas formas no me voy a dar por vencido y voy a continuar intentando modularizar mi kb y no morir en el intento.

GXUnit (Pruebas unitarias en GeneXus) (DEPRECATED)

En otro artículo comentaba que estaba contento por el resurgimiento de GXUnit pero después de actualizarme me di cuenta que en la actualidad se encuentra "Deprecated". En realidad no se actualiza desde hace un año y hoy en día no se puede descargar del Marketplace de GeneXus.

Estuve indagando y en la actualidad las pruebas unitarias se van a poder actualizar con GXTest4, en principio y por lo que tengo entendido el modulo de gxtest para realizar pruebas unitarias no tiene costo.

Básicamente creo que con GXTest4 voy a poder cumplir el objetivo de realizar pruebas unitarias y va a tener el mantenimiento necesario, esto ayuda a intentar poner recursos para la generación de pruebas unitarias en nuestros procesos de desarrollo.

Por lo que tengo entendido en la versión Tero estara integrado, para GeneXus 15 hay que bajarlo e instalarlo a mano. En mi caso ya lo tengo instalado y me encuentro por arrancar con mis primeras pruebas unitarias.

GXUnit (Pruebas unitarias en GeneXus)

En el último mes me encuentro en una búsqueda de mejorar el código que estoy desarrollando y la calidad de los productos en los que estoy participando. Mi motivación se basa en la necesidad de mejorar y adoptar una nueva cultura de trabajo en la cual pueda acompañar las tendencias de la industria de TI.

En principio creo que adoptar la cultura DevOps me permitiría acompañar los cambios necesarios para estar a la altura de los nuevos desafíos a los que me estoy enfrentando a diario.

La intención de comenzar en DevOps me ha llevado a investigar sobre Integración Continua y Liberación continua dentro de la Comunidad GeneXus.

Todo esto me ha llevado a volver a escuchar de la importancia de GXUnit y ver que por suerte ha tenido un resurgimiento, pueden leer mas en estos dos artículos:  GXUnit renace nuevamente y Renovando interés en GXUnit

También comparto los comentarios en donde se ve con asombro que la comunidad de usuarios no le damos la importancia que tiene el proyecto de GXUnit y realmente creo que tenemos que impulsar la utilización de pruebas unitarias en GeneXus.

Ahora me queda comenzar a implementar pruebas unitarias y ver como sacarle el mejor provecho a GXUnit.

GeneXus Modularity Maturity Model

Estoy intentando aplicar o seguir el GeneXus Modularity Maturity Model  planteado por Enrique Almeida, la verdad que es muy bueno poder llegar a tener todo organizado en módulos dado que cuando se trabaja con KB grandes o para proyectos muy grandes esto se hace mas que necesario.

En los proyectos que me encuentro tengo aplicaciones monolíticas que necesitan comenzar a utilizar módulos ya que se vuelve inmanejable tener KB con mas de 5000 objetos sin modularizar.

El principal problema que tengo es de Calidad y creo que al modularizar voy a poder tener este tema bajo control.

En síntesis siguiendo el GMMM me encuentro en el NIVEL 1, espero en próximas publicaciones poder contar del avance en el que me encuentro.

Mis pedidos para GeneXus Server

Desde hace algún tiempo estoy exigiendo bastante a GeneXus Server y le estoy encontrando algunos detalles que me gustaría que no estuvieran. Si tuviera la posibilidad de pedir algo me gustaría que si me bajo las versiones a mi kb local que las mismas se puedan actualizar si cambian en el server sin tener que volver a bajar todo creando una nueva kb.

Ej: Cuando hago el "Create Knowledge Base From GeneXus Server" me traigo las versiones existentes en el server: Digamos que tengo la versión 1.0, 1.1 y la 1.2. hago cambios y al pasar  tiempo en el server se crea la versión 1.3 en el servidor.

En este caso si quiero tener la versión 1.3 en mi copia local  no me queda otra que volver a crearme una nueva kb desde el server . Esto me implica tener que volver a generar todo y realmente alcanzaría con poder traerme la versión del server. Entiendo que seguramente exista algún problema o impedimento técnico que se me este escapando pero sería muy útil poder contar con esta opción.

Tengo formas de resolverlo pero es algo que me facilitaría la vida en la forma de trabajo que estamos implementando.

También tengo que pedir que en el update se pueda filtrar por los comentarios que se ponen en el commit ya que cuando SCM quiere bajar los objetos que fueron etiquetados en un comentario no lo puede hacer directamente si no que tiene que ir a la opción de history ver los objetos y luego marcarlos para bajar.