Design Patterns Handbook

A practical catalog of 37 reusable design patterns. Each entry explains the design intent, identifies a good fit, and includes a worked implementation followed by one detailed, concrete usage scenario in every programming language covered by Dev Handbooks.

Patterns are vocabulary for recurring design pressures, not requirements. Start with the simplest design and introduce a pattern when its trade-off solves a problem you actually have.

# Implementation
class ConnectionPool:
    def __init__(self):
        self._items = {}

    def acquire(self, key="default"):
        return self._items.setdefault(key, {"key": key})

# Usage
def main():
    connection_pool = ConnectionPool()
    first = connection_pool.acquire("primary")
    same = connection_pool.acquire("primary")
    primary = connection_pool.acquire("primary")
    same_primary = connection_pool.acquire("primary")
    secondary = connection_pool.acquire("secondary")

    assert primary is same_primary
    assert primary is not secondary

if __name__ == "__main__":
    main()

# Implementation
class SecureDocumentProxy:
    def __init__(self, target):
        self._target = target

    def read(self):
        result = self._target()
        return f"Proxy: {result}"

class PrimaryBehavior:
    def __call__(self, value):
        if not value:
            raise ValueError("value is required")
        return "document loaded"

class AlternateBehavior:
    def __call__(self, value):
        if not value:
            raise ValueError("value is required")
        return "access audited"

# Usage
def main():
    secure_document_proxy = SecureDocumentProxy(lambda: "completed")
    print(secure_document_proxy.read())  # => Proxy: completed
    timed = SecureDocumentProxy(lambda: secure_document_proxy.read())
    first = secure_document_proxy.read()
    second = timed.read()

    assert "completed" in first
    assert "completed" in second

if __name__ == "__main__":
    main()

# Implementation
class NullLogger:
    def log(self, message):
        pass

# Usage
def main():
    logger = NullLogger()
    logger.log("saved")
    class ConsoleLogger:
        def log(self, message):
            print(message)  # => order saved

    def save_order(logger):
        logger.log("order saved")

    save_order(NullLogger())
    save_order(ConsoleLogger())

if __name__ == "__main__":
    main()

# Implementation
class CheckoutSaga:
    def __init__(self):
        self._steps = []

    def add(self, step):
        self._steps.append(step)
        return self

    def start(self, value="request"):
        for step in self._steps:
            value = step(value)
        return value

# Usage
def main():
    checkout_saga = CheckoutSaga().add(lambda value: value.upper())
    result = checkout_saga.start()
    checkout_saga.add(lambda value: f"[{value}]")
    first = checkout_saga.start("first")
    second = checkout_saga.start("second")

    assert first == "[FIRST]"
    assert second == "[SECOND]"

if __name__ == "__main__":
    main()

Resilience & Resource Management Patterns

Circuit Breaker

Stops calls to a failing dependency temporarily, then probes it later to determine whether it recovered.

How it works

The breaker counts qualifying failures while closed and opens after a threshold, rejecting calls without contacting the dependency. After a cooldown it enters a half-open state, permits a limited probe, and closes again only after successful recovery.

When to use it

Use around remote dependencies to prevent cascading failures and give unhealthy services time to recover.

Trade-offs

Fail-fast behavior protects capacity and reduces cascading failure, but thresholds and timing require tuning. Pair the breaker with timeouts, bounded retries, monitoring, and a meaningful fallback where one exists.

python

# Implementation
class PaymentCircuitBreaker:
    def __init__(self, target, limit=3):
        self._target = target
        self._failures = 0
        self._limit = limit

    def call(self):
        if self._failures >= self._limit:
            raise RuntimeError("circuit open")
        try:
            return self._target()
        except Exception:
            self._failures += 1
            raise

# Usage
def main():
    breaker = PaymentCircuitBreaker(lambda: "paid")
    result = breaker.call()
    def unavailable():
        raise ConnectionError("payment service unavailable")

    failing_breaker = PaymentCircuitBreaker(unavailable, limit=2)
    errors = []
    for attempt in range(3):
        try:
            failing_breaker.call()
        except (ConnectionError, RuntimeError) as error:
            errors.append(str(error))

    assert failing_breaker._failures == 2
    assert errors[-1] == "circuit open"

if __name__ == "__main__":
    main()