¿Cómo podemos aplicar Clean Architecture sobre una base de código legado?
Esta es una de las preguntas que más veces me han hecho en el curso de Clean Architecture que llevo impartiendo desde 2016.
Trasladar los conocimientos de Clean Architecture a una base de código legado no es sencillo. Tienes que tener conocimientos de testing, refactoring y por su puesto, muy claros los conceptos de Clean Architecture.
He planteado un ejercicio de refactoring en varias empresas con las que he colaborado, después de la formación de Clean Architecture. El resultado a la primera no suele ser muy bueno. Normalmente, lo tienen que repetir.
El código inicial consiste en una pantalla de código legado con todas las malas prácticas posibles. El objetivo refactorizarla a Clean Architecture.
Cuando me muestran su solución, lo primero que les pido antes de evaluar el código es que ejecuten la aplicación.
Les pido que validen manualmente si la aplicación sigue funcionando igual que antes del refactor, el 90% de las veces han modificado el comportamiento.
La regla número 1 de refactoring: no modificar comportamiento.
En este punto hago ver que independientemente de lo bien o mal que este hecho el refactoring, si hemos modificado el comportamiento, el cliente no va a estar contento.
Posteriormente, cuando reviso el código, suele haber conceptos de Clean Architecture que no han sabido aplicar bien. Tratar de introducirlos sobre código legado incrementa la complejidad.
En alguna ocasiones, hay algunas personas que cuando me tienen que enseñar el ejercicio, ni les compila. Avanzando de la forma correcta, independientemente del tiempo del que dispongas, siempre tendrás avances estables.
Regla número 2 del refactoring: avanza en pasos pequeños que te permitan avanzar de forma segura.
Otra ventaja es poder revertir al paso anterior donde los test funcionaban si la liamos.
He creado un curso que trate de arrojar luz en este sentido: Cómo refactorizar a Clean Architecture en React.
Va a ser un curso totalmente práctico, donde me enfrentaré a un refactor usando React y TypeScript.
En el curso veremos cómo añadir tests para validar que no modificamos el comportamiento cuando tenemos que refactorizar una pantalla como a la que me enfrento en el curso.
También veremos como van emergiendo cada una de las responsabilidades avanzando en pequeños pasos.
Además, veremos qué pasos son los más adecuados cuando nos enfrentamos a un refactor de este tipo.
El curso no es en directo, es un curso grabado que podrás ver tantas veces como quieras y que estará disponible en una plataforma.
La tecnología, junto con el estado del código, condiciona cómo afrontar el ejercicio: el refactor, la estrategia de testing y los pasos a dar. Durante el curso explico los motivos de todos los pasos según los voy dando.
Precio 120 € + IVA
Cuando esté a la venta el curso lo anunciaré a través de la newsletter.
Preguntas frecuentes
¿A quién está dirigido este curso?
A personas que tienen claros los conceptos de Clean Architecture, pero:
- Les cuesta trasladarlos en su día a su base de código legado.
- No saben cómo aplicar estos conceptos en React.
¿Explicas Clean Architecture en este curso?
No, este curso no está pensado para personas que no conocen Clean Architecture.
No verás una presentación de teoría. Es un ejercicio avanzado totalmente práctico donde voy argumentando todos los pasos que doy, pero asumiendo que se tiene conocimientos de Clean Architecture.
Voy explicando todo el refactor que voy haciendo paso a paso, pero asumo que ya conoces los conceptos de Clean Architecture.
Para aprender sobre Clean Architecture desde cero te recomiendo este curso mio: Clean Architecture
¿Explicas testing en este curso?
No, es necesario que tengas unos mínimos conocimientos sobre testing para seguir el curso.
Simplemente explicó el motivo de la estrategia de testing que sigo pero no explico las bases del testing, tipos de test, dobles de test y muchos otros conceptos de testing.
¿Explicas refactoring en este curso?
No, es un ejercicio práctico donde explico algunos conceptos, los pasos que voy dando y la importancia de que sean pequeños.
Hay muchas estrategias de refactoring que no son necesarias en el refactor que aplicó y no las explico.