Me "ghostearon" como asesor externo

El término "ghostear" es la verbalización de la palabra ghost en inglés que significa fantasma. Y normalmente aplica cuando en una comunicación no presencial, ejemplo correos, mensajería, redes sociales, etc., de manera súbita tu interlocutor  literalmente desaparece del mapa, haciendo que todo  intento de contacto se pierda en el infinito.

Literalmente te hacen un > /dev/null

Bueno, les cuento la historia.
Nota al margen: Ojala no se aburran porque yo no creo en la historia corta, me voy a dar mil vueltas, voy a explicar mil cosas antes, y seguro va a parecer que me olvidé de lo que tenía que contar.

Algún tiempo atrás (en una galaxia muy lejana) me contacta un ex-compañero de trabajo, a quien le hice  más de un par de asesorías. La típica "¿en qué estás?" y "¿qué disposición tienes para  un trabajo extra?". La verdad es que el espíritu del mercenario nunca me ha abandonado, y el desafío se veía entretenido. Días después me contacta la jefa de proyecto que trabaja con él y me dice que "me vendieron" como alguien que puede solucionar cualquier problema. Debo confesar que la falsa humildad evita que yo me venda de esa manera, sin embargo mi arrogancia interna sabe que la maldita combinación de  inquietud intelectual y TOC normalmente  conducen a soluciones.

Trás un par de conversaciones acordamos una tarifa  x HH y me presentaron formalmente el desafío: Un sistema de facturación electrónica, cuyo backend está en Java con Spring Boot y el frontend en Angular.
Mi misión (que obviamente decidí aceptar) corregir/mejorar/hacer funcionar el formulario principal en la aplicacion Angular. Mi intervención sería solamente en el front. 

Diagnóstico inicial

Trás una revisión del código me quedaron claras varias cosas:

1. Quienes estuvieron a cargo de  hacer las definiciones iniciales no conocen bien las capacidades del framework (Angular).
2. La escuela inicial es Java, y si bien es cierto hay similitudes conceptuales entre la programación Java y Typescript, hay diferencias. No es llegar y traducir las estructuras. Hay cosas que se resuelven de otras maneras (GOTO 1)
3. Delegaron el desarrollo de partes sensibles de la aplicación a pollos digo.... desarrolladores menos  experimentados, ergo el desastre que empecé a ver en el código:
• Repetición de funciones.
• Funciones con múltiples responsabilidades (al bosillo la S de SOLID).
  
• Cero comprensión de los requerimientos, derivando en código  enredado, desordenado y complicado para requerimientos sencillos (golpeando a la fuerza con un martillo siempre se puede meter una pelota en el espacio de un cubo).
• Cero estándares de programación, desde la manera de nombrar las variables y funciones. indentación, tipo de comillas, etc.
• Cero documentación, sobretodo en aquellas partes "complejas".
• Desconocimiento importante de los conceptos básicos de OOP. 
• Desconocimiento de patrones de diseño.
  
• UN SÓLO gran componente con TODA la lógica de negocio en él. Más de 800 líneas de código, toda una obra de arte.
• Ausencia de una política clara de control de versiones. Usan git, así como  usamos calcetines.
  

Iban a ser jornadas de muuuucha diversión.

Cuando pesan las decisiones del pasado

Y no a mi en este caso. 

Empecemos:
Angular no es un framework sencillo. Tampoco es que sea taaaan complicado, pero no es sencillo, hay una base de OOP importante, y se le saca provecho en proyecto complejos (como el de este equipo), y más aún cuando hay conocimiento del framework.

Por ejemplo, uno de los pecados mortales que encontré, escribieron, o más bien arrastraron un servicio completo que extiende el HttpClient y agrega el token JWT de cada petición. ¡Sí! va a funcionar, pero... el HttpClient de Angular tiene soporte para los Interceptors, que van a actuar como middleware y pueden modificar las peticiones, no es necesario usar un httpGet propio que  agregue el token JWT a los headers. Lo peor de todo no fue tanto que lo arrastraran, sino que para peor, NO lo usaron en ningún lado y que cada una de las peticiones del sistema agregaba a mano el token.

Otro pecado mortal, servicios viejito, servicios... Salvo algunas contadas excepciones, claramente desarrolladas por otro pajarito (al menos eso decía el git log) TODAS las peticiones estaban dentro del giga-componente.

A ver, muy a grosso modo (siempre en el contexto de Angular):

• Componente: Unidad modular, habitualmente "tonta", sólo se encarga de desplegar información y reaccionar a ciertos eventos. No tiene lógica de negocio.
• Servicio: Es quien se encarga del "trabajo sucio". Los servicios saben que es lo que se tiene que hacer. Aquí hago una pequeña distinción, porque saber que se tiene que hacer es diferente a saber como hacerlo. Entonces tenemos 2 tipos de servicios que caerían en esta definición:
  
  • Facade: Fachada, que sabe que se tiene que hacer
  • Servicio (implementación específica): Sabe como hay que hacer loque se tiene que hacer.
    Y si, los 2 son servicios...
    

Y aquí seguro explotaron algunos cerebros, las cosas dejan de ser sencillas. Ya nada es como el tutorial de la PokeAPI o como el proyecto del Bootcamp.

Pero no sufran tanto, voy con un ejemplo.
Supongamos que su componente tiene que traerse datos desde "algún lugar", la respuesta que  reciben y saben procesar siempre tiene la misma forma (tipo de datos conocido), solo cambia el "desde donde" se van a traer los datos. Entonces el instinto te dice:

"Ahhhh! un servicio que tenga 2 metodos:

1. getDataHttp()
2. getDataLocal()"

Y si, va a funcionar, pero se acuerdan de la  O de SOLID, Open-closed principle abierto a la extensión, cerrado a la modificación, vale decir que si el comité creativo se le ocurren 20 origenes de datos diferentes, o te llenas de funciones  o te llenas de ifs.

Lo más razonable en términos de arquitectura es ver una implementación tipo Strategy o Factory, donde todo el resultado de tener un conexteto acotado

Nos fuimos a la B... no compa, me hubiera dedicado a la pastelería...

Y acá si me pongo a desarrollar el tema puedo escribir demasiado, SOLID da para  mucho.

Bueno, de SOLID el desarrollo base las pelotas. La idea me dio la sensación que fue buena, pero en la medida que pasó el tiempo y que no supieron mantener la consistencia en el código (y de paso de mantenerse al día cono cómo se desarrollaban los proyectos en cada nueva versión de Angular) los destrozos eran algo de esperar.

Entonces nuevamente se juntan los ingredientes claves para que Santa cobre caro y tenga  pega el desarrollo de un proyecto se empiece a volver caótico:

1. Bases mal definidas
2. Escaso conocimiento en el Framework
3. Equipo poco/mal capacitado

Si todo lo que pudiste decidir mal; por que no sabías o no te  supiste asesorar, o derechamente no te asesoraste ni investigaste; lo decidiste mal,  y seguiste una formula "conocida" que funcionó alguna vez, de seguro todas esas malas decisiones te van a cobrar factura después.

¿Qué fue lo que hice?

Literalmente lo de la imagen. El formulario principal era inicialmente un caos del que era cosa de gastarse unos minutos, dibujarlo a mano en papel y darse cuenta que se podía separar en componentes mucha más sencillos. 

Claro que alrededor tocó generar nuevos tipos de datos, definir servicios, extirpar funcionalidades, optimizar algunos procesos, ordenar el código, ordenar el código... Cuando visualicé la separación lógica para esto empecé a recortar el original, cada  "bloque" en su propio componente. Documentación adecuada, explicaciones a ciertas implementaciones oscuras, poco a poco  fue tomando sentido.

Pero no estuvo exento de dolores de cabeza, cosas que me hicieron pensar "¿Pero porqué este animalito  lo hizo así si <explicación razonable que hasta ChatGPT  indica sin fallas>?"

El plazo de entrega  era acotado, me demandó una jornada continua de 12 horas de programación, y finalmente  pospusieron esa reunión. Hubo algo de espacio extra para afinar detalles y de paso me pidieron "un extra".

El extra

Necesitaban que el generador de documentos funcionara. 

Contexto:
Los documentos tributarios electrónicos (DTE) pueden ser de diferentes tipos, factura, factura exenta, factura de exportación, boleta, nota de crédito, nota de débito y más de alguno que se me debe estar olvidando. Cada uno de estos tipos de  DTE se identifica con un código específico, y si bien comparten en forma muchas de las propiedades del documento, también difieren en algunas propiedades, según sea el tipo de documento. Eso ¿les da algún indicio de  por donde puede ir la cosa?

Vamos por parte:

1. Documentos "parecidos en forma"
2. Documentos "parecidos, pero con ciertas diferencias"
3. Documentos identificables según su tipo

Mi opinión se vuelve  algo sesgada (biased) al respecto, pero

¿tiene pinta de OOP o no tiene pinta de OOP? 

Y acá me pusieron pila, la idea era hacer un generador relativamente simple, relativamente fácil de entender y extender, pero por sobretodo una implementación elegante/medianamente elegante (aunque considerando la base casi cualquier cosa era mejora).

Entonces generé un estructura parecida a esta:

Entonces a través de un Factory rescataba la implementación  especifica para el documento que  quería generar. La interfaz del Documento me  indicaba los métodos que cada implementación  debía implementar. Eso más un Builder para poder generar instancias de cada documento usando los datos de cada sección del formulario, y  un Adapter para poder ajustarlos en forma para que el objeto sea "compatible" con lo que sabe manejar el backend.

Eso más mucha magia de Typescript, que también es algo que me llama demasiado la atención, y dentro de todo experticias que siempre fueron necesarias en este desarrollo.

Todo documentado, código "bonito" (y no porque lo diga yo), hasta un video les hice para explicar el proceso de la implementación. Claro que no profundicé en los patrones de diseño usados, eso literalmente da para un curso de  un semestre de universidad, y revisando el video un par de veces (no porque me guste el eco de como resuena mi propia voz) el video no es taaaaaaaan simple de entender, no sin una base medianamente sólida de OOP.

Quemé  más de un par de neuronas en el proceso.

Finalmente -> me "ghostearon"

Después de  caerse de espaldas con la factura que les mandé, porque no les salió barato (siendo que me aceptaron el precio x HH y que trabajé efectivamente cada hora que cobré) me consultaron si podía generarles un "proyecto base".

¿Qué sería este "proyecto base"?

De acuerdo a las mismas palabras de la JP "es un proyecto que tenga lo básico para poder empezar un proyecto, incluyendo buenas prácticas, etc."

Independiente de si trabajana o no en desarrollo de software es claro que TODOS los proyectos son diferentes, por mucho que estén basados en el starter-project, que de alguna manera busca ser esto.

Respecto a los starter-project, la idea no es mala, pero si tienes un triste precedente  de que aún con  ciertos lineamientos (buenos o malos, eso da lo mismo) de estructura de proyectos, tu equipo hizo un desastre, entonces por muy buenas prácticas que quieras poner en este starter-project  van a dejar el caos igual. Seamos realistas, por iniciativa propia un equipo rara vez se dedica a entender y aprender de  las buenas prácticas de un starter-project; habitualmente es un programemos encima a lo brutito, y si no hay un área de arquitectura que audite el desarrollo o una cultura de peer reviewing, no hay manera de sostener una arquitectura limpia.

Propuse en cambio capacitar al equipo, enseñarles  cómo se deben hacer las cosas, o quizás no exactamente el "cómo" que  puede resultar una posición impositiva, sino más bien qué enfoque se debe adoptar para poder llegar a una buena solución de software (mantenible, escalable, entendible, elegante...). sostuve mi propuesta con los argumentos que ya mencioné.

Y literalmente fue lo último que supe de esta empresa.
Llegó a ser  irónico pués  me  quitaron los accesos a los proyectos en git, salvo uno, y  ni siquiera me contestaron cuando se los indiqué.

¿De quién fue la culpa? (no eres tu soy yo...)

Mi 1er sospechoso es un poco la cultura de empresa, y esa mala valoración que le dan al trabajo y tiempo experto. Aquí yo sé que cobré caro, es la tarifa consultor habitual que suelo cobrar, precisamente porque me encargo que el producto que entrego valga lo que cuesta. 

Aquí tengo el ejemplo donde en cierta oportunidad quisieron negociar mi tarifa  x HH de consultoría  de manera equivalente a la HH a contrato de plazo fijo. En esa oportunidad mi cara de ¿cómo te lo explico sin que te sientas ofendido? fue épica.

Y mi 2do sospechoso fue  una frase final dentro del video donde explicaba la implementación del generador de documentos. Si volvemos atrás en este artículo nos daremos cuenta que  el generador es básicamernte contexto teórico, no hay nada que sea exclusivamente de frontend, por lo que puede ser  fácilmente aplicado al backend y lo más seguro es que  tenga los mismos beneficios relativos a la arquitectura de la solución.

Textualmente dije "...en vez de llenarnos de ifs, utilizamos  orientación a objetos como corresponde, hacemos distintas implementaciones y se nos simplifica infinitamente la existencia."

Me salió del alma ese cierre para el video. Ese tipo de verdades sin anestesia que no nos gusta escuchar sin decoración bonita.

Decirles a desarrolladores senior que programan en Java que no saben OOP y que no saben de  patrones de diseño es tan ají en el culo como decirle a un taxista que no sabe manejar... bien...