Design Patterns That Help Tame Legacy Code (With Python Examples)

Working with legacy code can feel like walking through a minefield. You know something might break, but you’re not sure when—or why. The good news is that design patterns can help.

In this post, I’ll share a few key design patterns that make working with legacy systems safer, cleaner, and more maintainable—using Python code examples.

🧩 1. The Adapter Pattern

Problem: Legacy code doesn’t match the interface your modern code expects.

Solution: Wrap the old code in a new interface.

Example:

Let’s say you have a legacy payment gateway:

# legacy_system.py
class LegacyPaymentProcessor:
    def make_payment(self, amount):
        print(f"[Legacy] Processing payment of ${amount}")

Now, you want to use a modern interface:

# adapter.py
class PaymentInterface:
    def pay(self, amount):
        raise NotImplementedError

class LegacyAdapter(PaymentInterface):
    def __init__(self, legacy_processor):
        self.legacy_processor = legacy_processor

    def pay(self, amount):
        return self.legacy_processor.make_payment(amount)

Usage:

from legacy_system import LegacyPaymentProcessor
from adapter import LegacyAdapter

adapter = LegacyAdapter(LegacyPaymentProcessor())
adapter.pay(100)

✅ You can now use LegacyPaymentProcessor anywhere PaymentInterface is expected.

🏗️ 2. The Facade Pattern

Problem: Legacy subsystems are complex and hard to use.

Solution: Provide a simplified interface to a larger body of code.

Example:

# legacy_subsystem.py
class LegacyAuth:
    def check_user(self, username, password):
        return username == "admin" and password == "1234"

class LegacyLogger:
    def log(self, msg):
        print(f"[LOG]: {msg}")

Facade:

class AuthFacade:
    def __init__(self):
        self.auth = LegacyAuth()
        self.logger = LegacyLogger()

    def login(self, username, password):
        if self.auth.check_user(username, password):
            self.logger.log(f"{username} logged in.")
            return True
        self.logger.log("Invalid login attempt.")
        return False

✅ Consumers don’t need to deal with the legacy details.

🧪 3. The Decorator Pattern

Problem: You want to add features without changing legacy code.

Solution: Wrap the legacy object to extend behavior dynamically.

Example:

class LegacyReporter:
    def report(self):
        print("Generating basic report...")

class TimestampedReporter:
    def __init__(self, wrapped):
        self.wrapped = wrapped

    def report(self):
        from datetime import datetime
        print(f"Report generated at: {datetime.now()}")
        self.wrapped.report()

Usage:

reporter = TimestampedReporter(LegacyReporter())
reporter.report()

✅ Legacy functionality extended without touching the original class.

🧰 4. The Strategy Pattern

Problem: You want to change algorithms used by legacy code without modifying it.

Solution: Inject behavior at runtime.

Example:

class LegacySorter:
    def sort(self, data):
        return sorted(data)  # default

# New strategy
class ReverseSortStrategy:
    def sort(self, data):
        return sorted(data, reverse=True)

# Updated to accept strategy
class SorterContext:
    def __init__(self, strategy):
        self.strategy = strategy

    def sort(self, data):
        return self.strategy.sort(data)

Usage:

sorter = SorterContext(ReverseSortStrategy())
print(sorter.sort([5, 1, 4, 2]))

✅ Clean separation of algorithms for flexible extension.

🚦 5. The Proxy Pattern

Problem: You need to add access control, caching, or logging to legacy classes.

Solution: Create a stand-in object that controls access to the real one.

Example:

class LegacyDatabase:
    def query(self, sql):
        print(f"Executing SQL: {sql}")
        return f"Results for: {sql}"

class LoggingProxy:
    def __init__(self, db):
        self.db = db

    def query(self, sql):
        print(f"[LOG] About to query: {sql}")
        return self.db.query(sql)

✅ Seamless control over legacy components.

✨ Wrapping Up

Design patterns are not just academic tools—they’re powerful allies when refactoring or integrating legacy code. With Python’s dynamic capabilities, implementing these patterns becomes even more fluid and expressive.