legacy

Legacy Modernization

Safely upgrade and modernize legacy systems.

When to Use

• Framework migrations
• Language version upgrades
• Monolith decomposition
• Technical debt reduction
• Dependency updates

Migration Strategies

Strangler Fig Pattern

┌─────────────────────────────────────┐
│           Load Balancer             │
└──────────────┬──────────────────────┘
               │
       ┌───────┴───────┐
       │               │
┌──────▼──────┐ ┌──────▼──────┐
│   Legacy    │ │    New      │
│   System    │ │   Service   │
└─────────────┘ └─────────────┘

1. Route new features to new service
2. Gradually migrate existing features
3. Eventually retire legacy system

Branch by Abstraction

# 1. Create abstraction layer
class PaymentProcessor(ABC):
    @abstractmethod
    def process(self, amount: float) -> bool:
        pass

# 2. Wrap legacy implementation
class LegacyPaymentProcessor(PaymentProcessor):
    def __init__(self, legacy_system):
        self.legacy = legacy_system

    def process(self, amount: float) -> bool:
        return self.legacy.old_process_method(amount)

# 3. Create new implementation
class ModernPaymentProcessor(PaymentProcessor):
    def process(self, amount: float) -> bool:
        # New implementation
        pass

# 4. Use feature flag to switch
processor = (ModernPaymentProcessor() if feature_flag("new_payment")
             else LegacyPaymentProcessor(legacy))

Migration Checklist

Before Starting

• Document current behavior
• Add tests for existing functionality
• Set up monitoring and alerts
• Create rollback plan
• Communicate with stakeholders

During Migration

• Make incremental changes
• Test after each change
• Monitor error rates
• Keep legacy running in parallel
• Document breaking changes

After Migration

• Remove feature flags
• Clean up legacy code
• Update documentation
• Archive old codebase
• Post-mortem lessons learned

Common Migrations

jQuery to React

// Phase 1: Embed React in jQuery app
const root = document.getElementById("new-component");
ReactDOM.render(<NewComponent />, root);

// Phase 2: Shared state
window.appState = { user: null };
// Both jQuery and React read from appState

// Phase 3: Gradual replacement
// Replace one component at a time

Python 2 to 3

# Use __future__ imports for compatibility
from __future__ import print_function, division, absolute_import

# Use six for cross-version compatibility
import six
if six.PY2:
    text_type = unicode
else:
    text_type = str

# Run 2to3 tool
# python -m lib2to3 --write --nobackups src/

Compatibility Layers

# Adapter for API changes
class CompatibilityAdapter:
    def __init__(self, new_service):
        self.new = new_service

    # Old API signature
    def get_user(self, user_id):
        # Translate to new API
        return self.new.fetch_user(id=user_id)

    # Deprecation warning
    def old_method(self):
        warnings.warn(
            "old_method is deprecated, use new_method instead",
            DeprecationWarning
        )
        return self.new.new_method()

Examples

Input: "Migrate from Express to Fastify" Action: Create adapter layer, migrate routes incrementally, test each step

Input: "Reduce technical debt in this module" Action: Add tests first, refactor incrementally, maintain compatibility