Coexistencia de código legado en sistemas de alta carga

Estabilidad sobre eliminación: estrategias para convivir con código heredado en proyectos grandes

En sistemas de larga duración y alto tráfico, eliminar el código heredado conlleva riesgos de regresiones e inestabilidad. En lugar de un refactoring completo, es más inteligente permitir que el código antiguo y nuevo coexistan mediante feature toggles y fachadas. Este enfoque permite desarrollo continuo sin tiempos de inactividad, manteniendo componentes probados como respaldo.

Riesgos de la eliminación agresiva del código

Incluso eliminar código muerto puede provocar fallos por dependencias ocultas: reflexión, carga dinámica, llamadas RPC. Las pruebas de sistemas heredados rara vez cubren casos extremos, y los datos de producción suelen activar caminos de ejecución poco frecuentes. La pérdida de conocimiento institucional agrava el problema: equipos que se van dejan atrás código crítico para escenarios específicos como migraciones o cumplimiento normativo.

En entornos empresariales, los módulos personalizados específicos de proveedores se vuelven vulnerables: cambios pueden romper el soporte del proveedor.

El principio "deja las cosas como están" en la práctica

Un ejemplo clásico es la sonda Deep Space 1 de la NASA: código de los años 70 permaneció sin tocar, envuelto en adaptadores. Los componentes estables no se modifican si funcionan bien. Esta estrategia madura se adapta a sistemas con más de cinco años de antigüedad.

Arquitectura de convivencia: la higuera estranguladora al revés

No destruyas el código heredado: construye el nuevo sistema en paralelo y desplaza gradualmente el tráfico. Dos estrategias:

| Estrategia | Acciones | Cuándo aplicar |

|----------|---------|----------------|

| Eliminación | Reescribir sobre una nueva pila | Lógica simple, cobertura de pruebas del 100%, sin dependencias |

| Convivencia | El nuevo código funciona junto al viejo, redirección progresiva | Funcionalidad crítica, pruebas débiles, alto riesgo |

Los feature toggles garantizan seguridad:

• Desarrolla la nueva implementación.
• Envuelve el código en una verificación de bandera.
• Ejecútalo en un 1% del tráfico.
• Escala si todo funciona bien.
• Revoca el cambio mediante la bandera si surgen problemas.

El código heredado permanece en el repositorio durante 2–3 años para análisis de fiabilidad.

Implementación en Spring Boot

Envuelve el código heredado en una interfaz sin modificar el original.

// Servicio heredado (sin tocar)
@Service
public class LegacyDiscountService {
    public double calculateDiscount(Order order) {
        // Lógica de hace cinco años
        return order.getTotal() * 0.1;
    }
}

// Nuevo servicio
@Service
public class NewDiscountService {
    public double calculateDiscount(Order order) {
        return applyComplexRules(order);
    }
}

Fachada con interruptor:

@Component
public class DiscountServiceFacade {
    private final LegacyDiscountService legacyService;
    private final NewDiscountService newService;
    
    @Value("${feature.discount.new.enabled:false}")
    private boolean useNewService;
    
    public DiscountServiceFacade(LegacyDiscountService legacyService, 
                                 NewDiscountService newService) {
        this.legacyService = legacyService;
        this.newService = newService;
    }
    
    public double calculateDiscount(Order order) {
        if (useNewService) {
            return newService.calculateDiscount(order);
        }
        return legacyService.calculateDiscount(order);
    }
}

Aislamiento mediante perfiles:

@Configuration
public class DiscountConfiguration {
    
    @Bean
    @ConditionalOnProperty(name = "feature.discount.new", havingValue = "false", matchIfMissing = true)
    public DiscountService legacyDiscountService() {
        return new LegacyDiscountService();
    }
    
    @Bean
    @ConditionalOnProperty(name = "feature.discount.new", havingValue = "true")
    public DiscountService newDiscountService() {
        return new NewDiscountService();
    }
}

Pruebas excluyen el código heredado:

@Test
@DisabledIf("!${feature.discount.new.enabled}")
void testNewDiscountLogic() {
    // Solo lógica nueva
}

Flujo de cambio de tráfico

La API Gateway redirige según banderas: el monolito como respaldo, el microservicio se escala progresivamente. El servicio de feature toggle gestiona porcentajes en tiempo real. El código heredado permanece en producción durante 2–3 años.

Cuando la eliminación es inevitable

• Seguridad: CVEs en bibliotecas obsoletas.
• Cumplimiento: Violaciones de GDPR.
• Tecnología EOL: Versiones de Java sin parches.
• Ausencia de expertos: No hay especialistas disponibles.

Incluso entonces: usa despliegue progresivo con capacidad de reversión.

Conclusiones clave

• La estabilidad del sistema supera la estética del código: la disponibilidad importa más que líneas borradas.
• Las dependencias ocultas requieren monitoreo de llamadas reales en producción antes de eliminar.
• Los feature toggles reducen los riesgos de migración.
• La deuda técnica tiene sentido si el costo de mantenimiento es menor que el de refactorización.
• El conocimiento institucional en el código: no lo elimines sin total confianza.

— Editorial Team