Softuy
Volver al blog
Publicado el: 20 de noviembre de 20269 min de lecturaDesarrollo de SoftwareRefactorización

Refactorizar sin romper: cómo mejorar código heredado paso a paso

El módulo ya tenía mala fama dentro del equipo. Cada vez que alguien tenía que tocarlo, aparecía la misma advertencia informal: “cuidado con eso, funciona, pero nadie sabe bien por qué”. No era una pieza espectacularmente compleja desde el punto de vista técnico. No tenía algoritmos difíciles ni integraciones imposibles. Su problema era más común y más peligroso: durante años había recibido pequeños cambios urgentes sin que nadie se detuviera a ordenar lo que iba quedando.

La primera reacción ante un código así suele ser extrema. Hay quien prefiere no tocar nada y agregar otro parche alrededor, porque cualquier modificación parece arriesgada. Y hay quien quiere rehacerlo todo, crear capas nuevas, aplicar Clean Architecture completa, separar cada responsabilidad, renombrar todos los conceptos y dejar una estructura ideal. Las dos respuestas nacen de una incomodidad real, pero las dos pueden salir caras.

No tocar nada mantiene el problema vivo. Reescribir todo puede romper comportamiento que nadie recuerda que existía.

Refactorizar sin romper exige un tercer camino: mejorar la estructura interna del código sin cambiar su comportamiento externo. Esa definición, habitual en la literatura de refactorización, es más importante de lo que parece. Refactorizar no es hacer que el código “se vea más lindo”. Tampoco es aprovechar una tarea para rediseñar medio sistema porque ahora conocemos un patrón mejor. Refactorizar es cambiar la forma sin cambiar el contrato observable.

Si antes una operación devolvía un resultado bajo ciertas condiciones, después de refactorizar debe seguir devolviendo el mismo resultado bajo esas mismas condiciones. Si una validación bloqueaba un caso, debe seguir bloqueándolo. Si un reporte dependía de una regla antigua, esa regla no puede desaparecer solo porque la nueva estructura parece más elegante. La refactorización profesional no empieza con entusiasmo arquitectónico. Empieza con respeto por el comportamiento existente.

Ese respeto no significa aceptar el desorden como destino. Significa entender que el código heredado, incluso cuando está mal escrito, suele contener conocimiento del negocio. Algunas condiciones existen por decisiones antiguas. Algunas excepciones cubren casos reales. Algunos nombres malos esconden reglas que alguien entendió en su momento, aunque ya no las haya explicado. Antes de mover una pieza, hay que distinguir entre lo accidental y lo esencial.

Imaginemos un método encargado de procesar una solicitud. Al principio solo validaba datos básicos. Con el tiempo empezó a verificar permisos, cambiar estados, calcular importes, enviar notificaciones y registrar auditoría. El método es largo, incómodo y difícil de leer. La tentación es dividirlo de inmediato en varias clases, crear servicios especializados y mover cada bloque a un lugar que suene más limpio.

Pero si nadie sabe exactamente qué comportamiento debe conservarse, esa limpieza puede convertirse en una forma ordenada de introducir errores.

El primer paso no es separar. El primer paso es observar.

Antes de refactorizar, conviene leer el flujo como si fuera una investigación. Qué datos entran, qué decisiones se toman, qué salidas produce, qué efectos secundarios ocurren y qué casos parecen especialmente sensibles. Si existen pruebas, esas pruebas actúan como una red de seguridad. Si no existen, tal vez la primera mejora no sea mover código, sino capturar con una prueba el comportamiento que no queremos romper.

Esta idea puede parecer lenta, pero en realidad evita la forma más cara de refactorización: aquella que deja el código más bonito y el sistema menos confiable.

Una técnica como Extract Method muestra bien el espíritu correcto. Extraer un método no debería ser un acto decorativo para reducir líneas. Tiene sentido cuando un fragmento del código expresa una intención que merece nombre propio. Si dentro del procesamiento de la solicitud hay un bloque que determina si el usuario puede realizar la acción, extraerlo como `PuedeModificarSolicitud` no solo reduce tamaño. También convierte una decisión escondida en una idea visible.

Ahí la refactorización mejora la comprensión.

El código sigue haciendo lo mismo, pero ahora el lector puede seguir el razonamiento con menos esfuerzo. No necesita interpretar veinte líneas mezcladas con otras responsabilidades para entender que existe una regla de autorización. El nombre del método funciona como una pequeña explicación del dominio. Esa es la diferencia entre ordenar por estética y ordenar para revelar intención.

Move Field o Move Method responden a una lógica parecida. No se trata de mover cosas porque una arquitectura ideal diga que “esto debería estar en otra capa”. Se trata de detectar que una responsabilidad vive en el lugar equivocado y que esa ubicación está encareciendo los cambios. Si una clase mantiene un dato que solo otra utiliza para tomar decisiones, quizá ese dato pertenece a la segunda. Si un método necesita demasiada información ajena para trabajar, tal vez está ubicado cerca de la clase incorrecta.

El criterio no es la pureza. El criterio es la dirección de las dependencias, la claridad de la decisión y el costo de modificar el comportamiento después.

Aquí aparece la relación con Clean Architecture y SOLID, pero también el riesgo de usarlos mal. Estos conceptos son herramientas para pensar límites, responsabilidades y dependencias. No son una obligación de convertir cada proyecto en una estructura de capas rígida, con carpetas impecables y abstracciones que nadie necesitaba todavía.

Separar capas tiene sentido cuando esa separación protege algo. Puede proteger reglas de negocio para que no dependan de detalles de infraestructura. Puede evitar que la interfaz arrastre decisiones que pertenecen al dominio. Puede permitir probar una regla sin levantar una base de datos o una API externa. Puede hacer que un cambio de proveedor no obligue a reescribir todo el flujo.

Pero separar capas solo por cumplir una forma también puede empeorar el sistema. Si una funcionalidad es pequeña, estable y simple, envolverla en interfaces, adaptadores, casos de uso, DTOs y servicios intermedios puede agregar más ruido que claridad. El código queda “arquitectónicamente correcto” en apariencia, pero entenderlo requiere saltar entre archivos que no aportan una decisión real. Esa también es una forma de deuda.

La arquitectura limpia sin fanatismo consiste en saber qué complejidad merece una frontera y cuál no.

Un Adapter, por ejemplo, puede ser muy útil cuando el sistema necesita aislarse de una API externa. Si mañana cambia el proveedor de pagos, de notificaciones o de almacenamiento, esa frontera puede ahorrar mucho dolor. Pero usar Adapter para cada clase que simplemente llama a otra dentro del mismo módulo puede convertir el proyecto en un laberinto de nombres formales sin beneficio concreto. El patrón no es bueno por existir. Es bueno cuando reduce una dependencia que realmente amenaza la evolución del sistema.

Lo mismo ocurre con Observer. Puede ser adecuado cuando varios componentes necesitan reaccionar a un evento sin quedar acoplados entre sí. Pero si se usa para esconder un flujo que debería ser explícito, el resultado puede ser peor: acciones que ocurren “por detrás”, difíciles de rastrear, donde nadie sabe exactamente qué se dispara cuando algo cambia. El patrón resuelve un problema de acoplamiento, pero también puede crear un problema de visibilidad si se aplica sin criterio.

Refactorizar bien requiere entender esa tensión. El objetivo no es llevar el código heredado hacia una arquitectura perfecta, sino hacia una arquitectura más honesta. Una estructura donde las responsabilidades importantes estén visibles, donde las dependencias tengan sentido y donde el próximo cambio sea un poco menos peligroso que el anterior.

Por eso la refactorización debería avanzar en pasos pequeños. Cambiar un nombre para revelar intención. Extraer una regla que estaba mezclada con otras. Separar una dependencia externa detrás de una interfaz cuando esa dependencia realmente condiciona el diseño. Mover un método hacia la clase que contiene los datos que usa. Agregar una prueba antes de tocar un flujo sensible. El progreso no siempre se ve como una gran transformación. A veces se ve como una reducción del miedo.

La palabra “paso” importa. Cuando un equipo intenta refactorizar demasiado en una sola operación, mezcla dos riesgos: el riesgo propio del cambio funcional y el riesgo de reorganizar la estructura. Si además no hay pruebas suficientes, revisar se vuelve casi imposible. Nadie sabe si el nuevo diseño rompió algo o si simplemente cambió la forma de llegar al mismo resultado.

En cambio, una refactorización pequeña permite comparar. Antes y después deberían comportarse igual. El diff debería contar una historia comprensible. El revisor debería poder decir: “esto no cambia la regla, solo le da un nombre”, o “esto no altera el flujo, solo mueve la dependencia a un lugar más adecuado”. Esa claridad protege al equipo.

También hay que aceptar que no todo código heredado merece la misma inversión. Un módulo estable, poco usado y con bajo riesgo puede no justificar una gran limpieza. En cambio, una zona que cambia todos los meses, concentra bugs y genera miedo cada vez que se toca está pidiendo atención. La refactorización no debería decidirse por incomodidad estética, sino por impacto: cuánto cuesta entender esa parte, cuántas veces se modifica, cuántos errores genera y cuánto bloquea al equipo.

Ese criterio evita dos errores comunes. El primero es la resignación, que acepta cualquier desorden porque “así funciona”. El segundo es el perfeccionismo, que intenta rediseñar todo antes de entregar valor. Entre ambos está el trabajo profesional: mejorar la estructura justo donde esa mejora reduce riesgo, tiempo o confusión.

Una Software Factory que domina la refactorización no evita que sus sistemas envejezcan. Todos los sistemas envejecen. Lo que evita es que cada cambio convierta ese envejecimiento en rigidez. El software puede evolucionar de forma orgánica si el equipo aprende a corregir la estructura mientras corrige el comportamiento, sin esperar a que el deterioro sea tan grande que solo quede hablar de reescritura.

La refactorización no es una fase separada de la vida del proyecto. Es una disciplina que acompaña el cambio. Cada vez que entendemos mejor una regla, el código puede expresarla mejor. Cada vez que una responsabilidad crece, podemos buscar un límite más claro. Cada vez que una dependencia empieza a molestar, podemos decidir si merece una frontera. Esa mejora continua es menos visible que una reescritura completa, pero mucho más sostenible.

El código heredado no se vuelve mantenible por una gran ceremonia arquitectónica. Se vuelve mantenible cuando el equipo aprende a tocarlo con cuidado, a proteger su comportamiento y a mejorar su estructura sin inventar complejidad innecesaria.

Refactorizar sin romper no significa moverse con miedo. Significa moverse con método.

La arquitectura, los patrones y los principios ayudan cuando permiten tomar mejores decisiones. Dejan de ayudar cuando se convierten en una obligación estética desconectada del problema. El objetivo no es que el código parezca sofisticado. El objetivo es que pueda seguir cambiando sin que cada cambio se sienta como una amenaza.

Ese es el equilibrio: mejorar lo suficiente para que el sistema respire, pero no tanto como para que la solución sea más difícil que el problema.

Refactorizar no es embellecer el código ni imponer una arquitectura ideal. Es mejorar la estructura con suficiente cuidado para que el sistema siga comportándose igual y pueda cambiar con menos miedo.

Compartir artículo

Resumen Ejecutivo

El artículo desarrolla cómo refactorizar código heredado sin alterar su comportamiento externo y sin convertir principios como Clean Architecture o SOLID en dogmas innecesarios.

Puntos Clave

  • Refactorizar es mejorar estructura sin cambiar comportamiento observable.
  • El primer paso ante código heredado no es separar, sino entender.
  • Patrones y capas ayudan cuando reducen dependencias reales.
  • La arquitectura limpia sin fanatismo evita tanto la resignación como la sobreingeniería.

Enfoque recomendado

"Artículo narrativo sobre cómo mejorar código heredado con método: proteger comportamiento, avanzar en pasos pequeños y aplicar arquitectura solo cuando aporte claridad real."