Design Patterns & LLD cheat sheet

1. Requirements (about 5 min): who uses it, what it must do, what is out of scope. Read 4 to 6 back.
2. Entities: underline the nouns. Identity and life means a class; a small value is a value object.
3. Class sketch: verbs become methods on the class that owns the data. Rules that may change go behind an interface.
4. Key flow as real code: at least one path is working, not hand-waved.
5. Extensions: show that a new rule is a small edit. Say a trade-off out loud.

Watch out: Do not name a pattern before the problem needs it. Say the pain first ("the fee rule will change"), then the pattern.

• Prefer composition ("has a") to inheritance ("is a"). Use extends only for a true is-a, when you own both classes.
• Classes are nouns, methods are verbs. Avoid Manager, Helper, Util. Make small classes readonly.

Watch out: Singleton traps: hidden dependency, shared test state, not one across processes or module URLs. Spread {...o} is a shallow copy.

• Decorator is chosen by the caller and the inner object always exists. Proxy may never touch the real object.
• Stack order matters: WithLog(WithCache(WithRetry(base))) caches the final answer. Cache inside retry checks the cache on every attempt.
• Keep add() on the composite only, so a leaf cannot be asked to add children.

• Strategy vs State: the caller picks a strategy; a state is the object's own condition and picks the next state.
• Observer: subscribe returns an unsubscribe function, loop over a copy, catch errors per listener.
• Command vs Strategy: a command is one request with data; keep it if you need history.

Express / Koa middleware

Chain of Responsibility with an onion: code after next() is a decorator

EventEmitter

Observer. Sync listeners, error with no listener throws, leaks

Redux

Action is a command as data, reducer is pure, subscribe is Observer

Custom hook

Reuse by composition, no base class

React Context

Dependency injection, not a store; all consumers re-render

JS Proxy

Dynamic decorator or guard; a trap runs on every access

Watch out: Request hangs? A middleware neither responded nor called next(), or called it twice, or forgot await next().

class Spot { fits(v); claim(plate);
  release() }
interface AllocationStrategy {
  choose(spots): Spot | undefined }
interface PricingStrategy {
  feeCents(v, minutes): number }
class HourlyPricing // rounds up
class DailyCap // decorates pricing
class ParkingLot {
  constructor(spots, alloc,
    pricing, now)
  park(v): Ticket | null
  unpark(id, v): { feeCents,
    minutes }
}

Tip: Check-then-act is a race. Make it one step: SQL UPDATE ... WHERE plate IS NULL (1 row), Redis SET NX.

• Hash map: buckets plus a hash function; chaining on collision. Resize at load factor about 0.75 and rehash every key (hash % buckets changes).
• LRU = Map from key to node + doubly linked list in use order. Sentinel head and tail remove edge cases.
• Store the key in the node, so evicting the tail can call map.delete(node.key).
• TTL: store expiresAt, check on get, inject the clock. Lazy expiry is simplest; a sweep frees memory sooner.

1. Name the states and events, then write the transition table first.
2. Every cell is a move or "not allowed". Prefer one state value to several booleans.
3. Pick the style: State pattern (object per state) for rich behaviour, table for mostly "go to X".
4. Failures are results; an invalid transition throws. Refund first, then change state.

• A Card is data. BlackjackHand scores, since an ace depends on the hand: count aces as 1, add 10 once if no bust.
• Shuffle with Fisher-Yates and inject the random source. Test rounds with stacked decks.
• Chat: User, FriendRequest (pending to accepted or rejected, once), Chat (members, messages), ChatServer enforces cross-object rules.
• Online delivery is Observer. Unread is a read position per user per chat. Order comes from per-chat ids.
• Call center: Chain of Responsibility (operator, supervisor, director) plus a queue when all are busy.

interface RateLimiter {
  allow(key, cost = 1): Decision
}  // allowed, remaining, retryAfterMs
class TokenBucket(cap, refill, now)
class FixedWindow(limit, ms, now)
class SlidingWindowLog(limit, ms)

Tip: Many servers: shared store with an atomic update, and decide fail open or fail closed. Delete idle full buckets.

EventBus

Observer: producers do not know who listens

Channel per medium

Strategy: add Slack with one class

templates

Data: text changes without code

withRetry

Backoff, cap, jitter, skip PermanentError

done keyed eventId:channel

Idempotency; store the promise for concurrent copies

deadLetters

Failures kept, not lost

• Wait before attempt n: random between 0 and min(cap, base * 2^n). Jitter stops a synchronised retry storm.
• Crash after send, before record, gives at-least-once. Pass your key to the provider to get closer to once.