// TypeScript — Strategy interface + two implementations
interface PricingStrategy {
  price(cart: Cart): number;
}

class StandardPricing implements PricingStrategy {
  price(cart: Cart): number {
    return cart.items.reduce((sum, i) => sum + i.price * i.qty, 0);
  }
}

class BlackFridayPricing implements PricingStrategy {
  price(cart: Cart): number {
    const total = cart.items.reduce((s, i) => s + i.price * i.qty, 0);
    return total * 0.7;
  }
}

class Checkout {
  constructor(private strategy: PricingStrategy) {}
  total(cart: Cart) { return this.strategy.price(cart); }
}

const checkout = new Checkout(new BlackFridayPricing());
console.log(checkout.total({ items: [{ price: 100, qty: 2 }] }));

140

from typing import Callable
from dataclasses import dataclass

@dataclass
class Cart:
    items: list[tuple[float, int]]   # (price, qty)

PricingStrategy = Callable[[Cart], float]

def standard(cart: Cart) -> float:
    return sum(p * q for p, q in cart.items)

def black_friday(cart: Cart) -> float:
    return standard(cart) * 0.7

def checkout(cart: Cart, strategy: PricingStrategy) -> float:
    return strategy(cart)

print(checkout(Cart([(100, 2)]), black_friday))

python checkout.py

140.0

# Python — minimal Observer
from typing import Callable

class EventBus:
    def __init__(self) -> None:
        self._handlers: dict[str, list[Callable]] = {}

    def on(self, event: str, handler: Callable) -> None:
        self._handlers.setdefault(event, []).append(handler)

    def emit(self, event: str, *args, **kwargs) -> None:
        for h in self._handlers.get(event, []):
            h(*args, **kwargs)

bus = EventBus()
bus.on("user.created", lambda u: print(f"audit: created {u}"))
bus.on("user.created", lambda u: print(f"email: welcome {u}"))
bus.emit("user.created", "alice@example.com")

python events.py

audit: created alice@example.com
email: welcome alice@example.com

// TypeScript — Factory function returning a tagged union
type Notifier =
  | { type: "email"; send: (to: string, msg: string) => void }
  | { type: "sms"; send: (to: string, msg: string) => void }
  | { type: "noop"; send: (to: string, msg: string) => void };

function createNotifier(kind: "email" | "sms" | "noop"): Notifier {
  switch (kind) {
    case "email":
      return { type: "email", send: (to, m) => console.log(`MAIL ${to}: ${m}`) };
    case "sms":
      return { type: "sms", send: (to, m) => console.log(`SMS ${to}: ${m}`) };
    case "noop":
      return { type: "noop", send: () => {} };
  }
}

const n = createNotifier(process.env.NOTIFIER === "sms" ? "sms" : "email");
n.send("alice@example.com", "hello");

NOTIFIER=sms node notifier.js

SMS alice@example.com: hello

# Python — Adapter between a legacy logger and a modern Logger interface
class LegacyLogger:
    def write(self, level: int, text: str) -> None:
        print(f"[{level}] {text}")

class Logger:
    """Modern interface used everywhere in this codebase."""
    def info(self, msg: str) -> None: ...
    def error(self, msg: str) -> None: ...

class LegacyLoggerAdapter(Logger):
    LEVEL = {"info": 1, "error": 3}
    def __init__(self, legacy: LegacyLogger) -> None:
        self._legacy = legacy
    def info(self, msg: str) -> None:
        self._legacy.write(self.LEVEL["info"], msg)
    def error(self, msg: str) -> None:
        self._legacy.write(self.LEVEL["error"], msg)

log: Logger = LegacyLoggerAdapter(LegacyLogger())
log.info("startup")
log.error("disk full")

python adapter.py

[1] startup
[3] disk full

# Python — caching decorator on top of a slow function
from functools import lru_cache
import time

@lru_cache(maxsize=128)
def fetch_user(user_id: int) -> dict:
    time.sleep(0.5)
    return {"id": user_id, "name": f"user-{user_id}"}

t0 = time.time(); fetch_user(1)
t1 = time.time(); fetch_user(1)   # cached, instant
t2 = time.time()
print(f"first: {t1-t0:.2f}s, second: {t2-t1:.4f}s")

python cache_decorator.py

first: 0.50s, second: 0.0001s

// TypeScript — logging Decorator over a Repository interface
interface UserRepo {
  findById(id: number): Promise<User | null>;
}

class LoggingRepo implements UserRepo {
  constructor(private inner: UserRepo) {}
  async findById(id: number): Promise<User | null> {
    const t0 = Date.now();
    const result = await this.inner.findById(id);
    console.log(`findById(${id}) → ${result ? "hit" : "miss"} in ${Date.now() - t0}ms`);
    return result;
  }
}

const repo: UserRepo = new LoggingRepo(new SqlUserRepo(db));

// TypeScript — Repository interface + two implementations
interface User { id: number; email: string; name: string }

interface UserRepository {
  findById(id: number): Promise<User | null>;
  save(user: User): Promise<void>;
}

// Production implementation
class PostgresUserRepository implements UserRepository {
  constructor(private db: Pool) {}
  async findById(id: number) {
    const { rows } = await this.db.query("SELECT * FROM users WHERE id=$1", [id]);
    return rows[0] ?? null;
  }
  async save(u: User) {
    await this.db.query(
      "INSERT INTO users(id,email,name) VALUES($1,$2,$3) ON CONFLICT(id) DO UPDATE SET email=$2,name=$3",
      [u.id, u.email, u.name],
    );
  }
}

// Test implementation
class InMemoryUserRepository implements UserRepository {
  private store = new Map<number, User>();
  async findById(id: number) { return this.store.get(id) ?? null; }
  async save(u: User) { this.store.set(u.id, u); }
}

// Domain service depends only on the interface
class WelcomeService {
  constructor(private repo: UserRepository) {}
  async welcome(id: number) {
    const u = await this.repo.findById(id);
    return u ? `Hi ${u.name}` : "Unknown user";
  }
}

test("welcome", async () => {
  const repo = new InMemoryUserRepository();
  await repo.save({ id: 1, email: "alice@example.com", name: "Alice Dev" });
  const svc = new WelcomeService(repo);
  expect(await svc.welcome(1)).toBe("Hi Alice Dev");
});

npx vitest run user.test.ts

 ✓ welcome
Test Files  1 passed (1)
     Tests  1 passed (1)

# DON'T — classic singleton (Python)
class Config:
    _instance: "Config | None" = None
    def __new__(cls):
        if cls._instance is None:
            cls._instance = super().__new__(cls)
        return cls._instance

# DO — construct once, pass explicitly
def make_app(config: Config) -> App:
    repo = UserRepo(config.db_url)
    return App(config, repo)

if __name__ == "__main__":
    app = make_app(Config.load())
    app.run()

// TypeScript — Command with undo for a text editor
interface Command { execute(): void; undo(): void; }

class InsertText implements Command {
  constructor(private doc: { text: string }, private at: number, private str: string) {}
  execute() { this.doc.text = this.doc.text.slice(0, this.at) + this.str + this.doc.text.slice(this.at); }
  undo()    { this.doc.text = this.doc.text.slice(0, this.at) + this.doc.text.slice(this.at + this.str.length); }
}

class History {
  private stack: Command[] = [];
  do(cmd: Command) { cmd.execute(); this.stack.push(cmd); }
  undo() { this.stack.pop()?.undo(); }
}

const doc = { text: "hello" };
const h = new History();
h.do(new InsertText(doc, 5, " world"));
console.log(doc.text);
h.undo();
console.log(doc.text);

node command.js

hello world
hello

# Python — order lifecycle
class OrderState:
    def pay(self, ctx): raise NotImplementedError
    def ship(self, ctx): raise NotImplementedError
    def cancel(self, ctx): raise NotImplementedError

class Pending(OrderState):
    def pay(self, ctx): ctx.state = Paid(); print("paid")
    def ship(self, ctx): print("cannot ship unpaid order")
    def cancel(self, ctx): ctx.state = Cancelled(); print("cancelled")

class Paid(OrderState):
    def pay(self, ctx): print("already paid")
    def ship(self, ctx): ctx.state = Shipped(); print("shipped")
    def cancel(self, ctx): ctx.state = Refunded(); print("refunded")

class Shipped(OrderState):
    def pay(self, ctx): print("already paid")
    def ship(self, ctx): print("already shipped")
    def cancel(self, ctx): print("cannot cancel a shipped order")

class Cancelled(OrderState):  # terminal
    def pay(self, ctx): print("cancelled — no payments")
    def ship(self, ctx): print("cancelled — no shipments")
    def cancel(self, ctx): print("already cancelled")

class Refunded(OrderState):   # terminal
    def pay(self, ctx): print("refunded — no payments")
    def ship(self, ctx): print("refunded — no shipments")
    def cancel(self, ctx): print("already refunded")

class Order:
    def __init__(self): self.state: OrderState = Pending()
    def pay(self): self.state.pay(self)
    def ship(self): self.state.ship(self)
    def cancel(self): self.state.cancel(self)

o = Order()
o.ship()   # rejected
o.pay()
o.ship()
o.cancel() # rejected — already shipped

python order_state.py

cannot ship unpaid order
paid
shipped
cannot cancel a shipped order

# Python generator — Iterator pattern in one line
def line_iter(path: str):
    with open(path) as f:
        for line in f:
            yield line.rstrip("\n")

for line in line_iter("access.log"):
    if "ERROR" in line:
        print(line)

python iter.py

2026-05-25 10:01:55 ERROR DB connection lost
2026-05-25 10:02:33 ERROR auth failed for user alice@example.com

# Python — Template Method for data import jobs
from abc import ABC, abstractmethod
import time

class ImportJob(ABC):
    def run(self) -> None:
        t0 = time.time()
        data = self.fetch()
        cleaned = self.clean(data)
        self.persist(cleaned)
        print(f"imported {len(cleaned)} rows in {time.time()-t0:.2f}s")

    @abstractmethod
    def fetch(self) -> list[dict]: ...
    def clean(self, rows: list[dict]) -> list[dict]:
        return [r for r in rows if r]
    @abstractmethod
    def persist(self, rows: list[dict]) -> None: ...

class CsvImport(ImportJob):
    def __init__(self, path: str): self.path = path
    def fetch(self) -> list[dict]:
        return [{"id": 1, "name": "Alice Dev"}, {"id": 2, "name": "Bob"}]
    def persist(self, rows: list[dict]) -> None:
        for r in rows: print("INSERT", r)

CsvImport("users.csv").run()

python template.py

INSERT {'id': 1, 'name': 'Alice Dev'}
INSERT {'id': 2, 'name': 'Bob'}
imported 2 rows in 0.00s

// TypeScript — query Builder
class QueryBuilder {
  private parts: { table?: string; where: string[]; order?: string; limit?: number } = { where: [] };
  from(t: string)            { this.parts.table = t; return this; }
  where(s: string)           { this.parts.where.push(s); return this; }
  orderBy(s: string)         { this.parts.order = s; return this; }
  limit(n: number)           { this.parts.limit = n; return this; }
  build(): string {
    const where = this.parts.where.length ? ` WHERE ${this.parts.where.join(" AND ")}` : "";
    const order = this.parts.order ? ` ORDER BY ${this.parts.order}` : "";
    const limit = this.parts.limit ? ` LIMIT ${this.parts.limit}` : "";
    return `SELECT * FROM ${this.parts.table}${where}${order}${limit}`;
  }
}

const sql = new QueryBuilder()
  .from("users")
  .where("active = true")
  .where("created_at > NOW() - INTERVAL '30 days'")
  .orderBy("created_at DESC")
  .limit(20)
  .build();

console.log(sql);

node builder.js

SELECT * FROM users WHERE active = true AND created_at > NOW() - INTERVAL '30 days' ORDER BY created_at DESC LIMIT 20

# Python — middleware-style chain
from typing import Callable

Handler = Callable[[dict, Callable], dict]

def auth(req, nxt):
    if not req.get("token"): return {"status": 401, "body": "unauthorized"}
    return nxt(req)

def logger(req, nxt):
    print(f"-> {req['path']}")
    resp = nxt(req)
    print(f"<- {resp['status']}")
    return resp

def handler(req, nxt):
    return {"status": 200, "body": f"hello {req['path']}"}

def chain(*fns: Handler) -> Handler:
    def call(req, nxt=None):
        i = 0
        def step(req):
            nonlocal i
            if i >= len(fns): return nxt(req) if nxt else {"status": 404}
            fn = fns[i]; i += 1
            return fn(req, step)
        return step(req)
    return call

app = chain(logger, auth, handler)
print(app({"path": "/", "token": "abc"}))
print(app({"path": "/", "token": ""}))

python chain.py

-> /
<- 200
{'status': 200, 'body': 'hello /'}
-> /
<- 401
{'status': 401, 'body': 'unauthorized'}

# Python 3.10+ — structural pattern matching as Visitor
from dataclasses import dataclass

@dataclass
class Num: value: int
@dataclass
class Add: left: "Expr"; right: "Expr"
@dataclass
class Mul: left: "Expr"; right: "Expr"
Expr = Num | Add | Mul

def evaluate(e: Expr) -> int:
    match e:
        case Num(v): return v
        case Add(l, r): return evaluate(l) + evaluate(r)
        case Mul(l, r): return evaluate(l) * evaluate(r)

def to_str(e: Expr) -> str:
    match e:
        case Num(v): return str(v)
        case Add(l, r): return f"({to_str(l)} + {to_str(r)})"
        case Mul(l, r): return f"({to_str(l)} * {to_str(r)})"

tree = Add(Num(2), Mul(Num(3), Num(4)))
print(to_str(tree), "=", evaluate(tree))

python visitor.py

(2 + (3 * 4)) = 14

// src/checkout/index.ts
import { StandardPricing, BlackFridayPricing, type PricingStrategy } from "./strategies";

const STRATEGIES: Record<string, () => PricingStrategy> = {
  standard:     () => new StandardPricing(),
  black_friday: () => new BlackFridayPricing(),
};

export function pricingFor(env: { PRICING: string }): PricingStrategy {
  const make = STRATEGIES[env.PRICING];
  if (!make) throw new Error(`unknown pricing strategy: ${env.PRICING}`);
  return make();
}

// src/users/repo.ts
const base = new PostgresUserRepository(db);
const cached = new CachingUserRepository(base, redis, { ttlSeconds: 60 });
const logged = new LoggingUserRepository(cached);
export const userRepo: UserRepository = logged;

type Result =
  | { kind: "ok"; value: User }
  | { kind: "not_found"; id: number }
  | { kind: "error"; reason: string };

function loadUser(id: number): Result { /* ... */ return { kind: "ok", value: { id, email: "a@b.c", name: "Alice Dev" } }; }

const r = loadUser(42);
switch (r.kind) {
  case "ok":         return r.value;
  case "not_found":  console.warn(`missing ${r.id}`); break;
  case "error":      console.error(r.reason); break;
}

// Useful for global event buses in long-lived apps
function on<T>(bus: EventEmitter, event: string, handler: (e: T) => void): () => void {
  bus.on(event, handler);
  return () => bus.off(event, handler);
}

// React: useEffect returns the cleanup
useEffect(() => on(bus, "user.created", refresh), [refresh]);

class History {
  private done: Command[] = [];
  private redoStack: Command[] = [];
  do(cmd: Command) { cmd.execute(); this.done.push(cmd); this.redoStack = []; }
  undo() { const c = this.done.pop(); if (c) { c.undo(); this.redoStack.push(c); } }
  redo() { const c = this.redoStack.pop(); if (c) { c.execute(); this.done.push(c); } }
}

# transitions library — declarative state machine
from transitions import Machine

states = ["trial", "active", "past_due", "cancelled"]
transitions = [
    {"trigger": "subscribe", "source": "trial",     "dest": "active"},
    {"trigger": "fail",      "source": "active",    "dest": "past_due"},
    {"trigger": "recover",   "source": "past_due",  "dest": "active"},
    {"trigger": "cancel",    "source": ["trial", "active", "past_due"], "dest": "cancelled"},
]

class Account:
    def __init__(self): Machine(self, states=states, transitions=transitions, initial="trial")

a = Account()
a.subscribe()
print(a.state)
a.fail()
print(a.state)
a.recover()
print(a.state)

python billing_fsm.py

active
past_due
active