Reference library

System design patterns

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

5 matches

How to Apply the Clean Architecture Dependency Rule in Python

Demonstrates the dependency rule with a Protocol repository, a use case, and a presenter wired together at a composition root.

clean-architecture dependency-inversion protocol

Python

from dataclasses import dataclass
from typing import List, Protocol

class Repository(Protocol):
    def get_items(self) -> List[str]:
        ...

@dataclass
class InMemoryRepository:
    items: List[str]

    def get_items(self) -> List[str]:
        return self.items

class UseCase:
    """Application layer depends…

13 0 Open

System design patterns medium

How to Build an Adapter to Translate External API Responses in Python

Build an adapter class that translates a mock external API's response shape into your internal representation, keeping callers decoupled from the external contract.

adapter-pattern api architecture

Python

import json
from typing import Dict, Any


class ExternalAPI:
    """Mock external service returning a different data shape."""
    def get_user(self, user_id: int) -> Dict[str, Any]:
        return {
            "id": user_id,
            "full_name": "Jane Doe",
            "email_address": "jane@example.com",
     …

14 0 Open

System design patterns medium

How to Implement a Simple MVVM Binding Mock in Python

A minimal Python implementation of the MVVM pattern, mocking data binding so views auto-update when the view model changes.

mvvm binding observer pattern

Python

class BindingMock:
    def __init__(self, view_model):
        self.view_model = view_model
        self.subscribers = []

    def bind(self, property_name, callback):
        self.subscribers.append((property_name, callback))

    def set(self, property_name, value):
        setattr(self.view_model, property_name, va…

18 0 Open

System design patterns medium

How to Structure a Three-Tier Layered Architecture in Python

A mock three-tier architecture with presentation, business, and data layers that process a user request from input to response.

architecture layered design-pattern

Python

class PresentationLayer:
    def __init__(self, business_layer):
        self.business = business_layer

    def handle_request(self, user_id):
        print(f"[Presentation] Received request for user {user_id}")
        data = self.business.process_user(user_id)
        print(f"[Presentation] Response: {data}")
     …

12 0 Open

System design patterns medium

Microkernel Plug-in Core Mock in Python

Implements a minimal microkernel plug-in core that registers, unregisters, and executes synchronous or asynchronous plugins via a pluggable manager class.

microkernel plugin design-patterns

Python

import json
import abc
import inspect


class MicrokernelCore(abc.ABC):

    def __init__(self):
        self._plugins = {}

    def register(self, name, plugin):
        self._plugins[name] = plugin

    def unregister(self, name):
        return self._plugins.pop(name, None)

    def execute(self, name, *args, **kwa…

13 0 Open

Browse by section

Each section groups closely related Python snippets.