Reference library

System design patterns

Sharding, load balancing, CAP tradeoffs, and scaling patterns — interview and production ready.

5 matches

Facade Pattern in Python with Mock Simplification

This code demonstrates the Facade pattern by hiding complex subsystem interactions behind a simple start/stop interface, and adds a MockFacade for testing failure scenarios.

facade-pattern design-patterns abstraction

Python

class SubsystemA:
    def operation_a(self):
        return "Subsystem A: ready"

class SubsystemB:
    def operation_b(self):
        return "Subsystem B: ready"

class SubsystemC:
    def operation_c(self):
        return "Subsystem C: ready"


class Facade:
    def __init__(self):
        self._a = SubsystemA()
   …

15 0 Open

System design patterns medium

How to Build an Anti-Corruption Layer in Python

Wrap a legacy system with a translation layer that converts awkward legacy data into a clean, modern DTO (Data Transfer Object) for use by new code.

anti-corruption-layer ddd dto

Python

class LegacyOrderSystem:
    """Legacy system with awkward, unstructured data."""
    def get_order(self):
        return {
            "order_id": "ORD-123",
            "cust": "Acme Corp",
            "items": [{"sku": "A1", "qty": 2, "price_each": 10.0}],
            "ship_to": "123 Main St, Springfield"
        }…

15 0 Open

System design patterns medium

How to Implement the Abstract Factory Pattern in Python

Implements the Abstract Factory pattern to create families of related GUI objects (buttons, checkboxes) without specifying their concrete classes.

abstract-factory design-patterns system-design

Python

from abc import ABC, abstractmethod


class Button(ABC):
    @abstractmethod
    def render(self):
        pass


class Checkbox(ABC):
    @abstractmethod
    def render(self):
        pass


class WindowsButton(Button):
    def render(self):
        return "Rendering Windows-style button"


class WindowsCheckbox(Chec…

13 0 Open

System design patterns medium

Implement a Consistent Hash Ring in Python

Build a minimal consistent hash ring with virtual nodes to map keys to servers stably as nodes are added or removed.

consistent-hashing hashing distributed-systems

Python

import hashlib
import bisect


class ConsistentHashRing:
    def __init__(self, nodes=None, replicas=3):
        self.replicas = replicas
        self.ring = {}
        self.sorted_keys = []
        if nodes:
            for node in nodes:
                self.add_node(node)

    def _hash(self, key):
        return i…

15 0 Open

System design patterns medium

Simulate a Leaky Bucket Rate Limiter in Python

This code implements a leaky bucket rate limiter that drains at a fixed rate and accepts or rejects incoming requests based on capacity.

rate limiting leaky bucket simulation

Python

import time
from collections import deque


class LeakyBucket:
    """Simulates a leaky bucket rate limiter with a fixed drain rate."""
    def __init__(self, capacity, drain_rate_per_sec):
        self.capacity = capacity
        self.drain_rate = drain_rate_per_sec
        self.water = 0.0
        self.last_refill =…

13 0 Open

Browse by section

Each section groups closely related Python snippets.