Choosing a pattern

The last page turns the catalogue around: start from what hurts in the code, find the pattern that makes that change cheap, and check that the problem is real before building anything. With a symptom table, common combinations, and one ride passing through four patterns at once.

1. Two ways to go wrong

Pattern trouble comes in two opposite kinds. Too little: the same if kind == … chain in five functions, paging loops copied into three screens, a ride service that every team edits. Too much: a PricingStrategyFactoryProvider wrapping the one pricing rule that has never changed, three layers of indirection for something a function would do.

Both come from choosing a pattern by its name rather than by the problem in front of you. This page turns the track around: start from the symptom in the code, find the pattern that answers it, and check whether the problem is real yet.

2. Choosing in one picture

Start with the kind of pain. Is it about making objects (which class, how assembled), fitting objects together (interfaces that don't match, behaviour to wrap around, structures to treat alike), choosing behaviour (an algorithm or state that varies, requests to queue or chain), or objects talking (who needs to know, who coordinates, how to walk or extend a structure)? Then pick within that group using the symptom table below.

And before any of it, ask whether the second case exists yet. A pattern earns its place when there's real variation or change to absorb. One pricing rule needs a function; the third one might need a strategy.

3. Symptom to pattern

4. Patterns that work together

Real designs combine patterns. These pairs come up again and again; each pair solves two problems that tend to appear together.

5. One ride, four patterns

One small program where a simple factory makes the vehicle, strategies price two rides, a decorator logs every price and observers react to each finished ride. Each line is tagged with the pattern that produced it.

from __future__ import annotations
from abc import ABC, abstractmethod
from typing import Callable


# [simple factory] which class to create, decided in one place
class Vehicle:
    def __init__(self, vid: str, kind: str) -> None:
        self.vid, self.kind = vid, kind


def make_vehicle(kind: str, vid: str) -> Vehicle:
    if kind not in ("bike", "e-bike"):
        raise ValueError(f"unknown vehicle kind '{kind}'")
    return Vehicle(vid, kind)


# [strategy] the pricing rule is swappable
class Pricing(ABC):
    name = ""

    @abstractmethod
    def price(self, minutes: int) -> int: ...


class Member(Pricing):
    name = "member"
    def price(self, minutes: int) -> int: return max(0, minutes - 30) * 10


class PayAsYouGo(Pricing):
    name = "pay-as-you-go"
    def price(self, minutes: int) -> int: return 100 + minutes * 10


# [decorator] logging wrapped around any pricing, same interface
class Logged(Pricing):
    def __init__(self, inner: Pricing, log: list[str]) -> None:
        self.inner, self.log, self.name = inner, log, inner.name

    def price(self, minutes: int) -> int:
        p = self.inner.price(minutes)
        self.log.append(f"{self.name} {minutes} min -> {p}p")
        return p


# [observer] whoever cares about a finished ride subscribes
class Rides:
    def __init__(self) -> None:
        self.listeners: list[Callable[[str, int], str]] = []

    def end(self, rider: str, pence: int) -> list[str]:
        return [fn(rider, pence) for fn in self.listeners]


if __name__ == "__main__":
    log: list[str] = []
    rides = Rides()
    rides.listeners.append(lambda rider, p: f"billing: charged {rider} {p}p")
    rides.listeners.append(lambda rider, p: "map: S-31 +1 bike")
    bike = make_vehicle("e-bike", "E-205")
    print(f"[factory]   dock D7 released {bike.kind} {bike.vid}")
    for rider, pricing, minutes in [("mia", Member(), 42), ("leo", PayAsYouGo(), 18)]:
        pence = Logged(pricing, log).price(minutes)
        print(f"[strategy]  {rider}: {pricing.name}, {minutes} min -> {pence}p")
        print(f"[observer]  " + " | ".join(rides.end(rider, pence)))
    print(f"[decorator] log: " + "; ".join(log))

// [simple factory] which class to create, decided in one place
class Vehicle { constructor(readonly vid: string, readonly kind: string) {} }
function makeVehicle(kind: string, vid: string): Vehicle {
  if (kind !== "bike" && kind !== "e-bike") throw new Error(`unknown vehicle kind '${kind}'`);
  return new Vehicle(vid, kind);
}

// [strategy] the pricing rule is swappable
interface Pricing { readonly name: string; price(minutes: number): number; }
class Member implements Pricing { readonly name = "member"; price(m: number) { return Math.max(0, m - 30) * 10; } }
class PayAsYouGo implements Pricing { readonly name = "pay-as-you-go"; price(m: number) { return 100 + m * 10; } }

// [decorator] logging wrapped around any pricing, same interface
class Logged implements Pricing {
  readonly name: string;
  constructor(private readonly inner: Pricing, private readonly log: string[]) { this.name = inner.name; }
  price(minutes: number): number {
    const p = this.inner.price(minutes);
    this.log.push(`${this.name} ${minutes} min -> ${p}p`);
    return p;
  }
}

// [observer] whoever cares about a finished ride subscribes
class Rides {
  readonly listeners: ((rider: string, pence: number) => string)[] = [];
  end(rider: string, pence: number): string[] { return this.listeners.map((fn) => fn(rider, pence)); }
}

const log: string[] = [];
const rides = new Rides();
rides.listeners.push((rider, p) => `billing: charged ${rider} ${p}p`);
rides.listeners.push(() => "map: S-31 +1 bike");
const bike = makeVehicle("e-bike", "E-205");
console.log(`[factory]   dock D7 released ${bike.kind} ${bike.vid}`);
const trips: [string, Pricing, number][] = [["mia", new Member(), 42], ["leo", new PayAsYouGo(), 18]];
for (const [rider, pricing, minutes] of trips) {
  const pence = new Logged(pricing, log).price(minutes);
  console.log(`[strategy]  ${rider}: ${pricing.name}, ${minutes} min -> ${pence}p`);
  console.log("[observer]  " + rides.end(rider, pence).join(" | "));
}
console.log("[decorator] log: " + log.join("; "));

import java.util.ArrayList;
import java.util.List;
import java.util.function.BiFunction;

public class Main {
    // [simple factory] which class to create, decided in one place
    record Vehicle(String vid, String kind) {}
    static Vehicle makeVehicle(String kind, String vid) {
        if (!kind.equals("bike") && !kind.equals("e-bike")) throw new IllegalArgumentException("unknown vehicle kind '" + kind + "'");
        return new Vehicle(vid, kind);
    }

    // [strategy] the pricing rule is swappable
    interface Pricing { String name(); int price(int minutes); }
    static class Member implements Pricing { public String name() { return "member"; } public int price(int m) { return Math.max(0, m - 30) * 10; } }
    static class PayAsYouGo implements Pricing { public String name() { return "pay-as-you-go"; } public int price(int m) { return 100 + m * 10; } }

    // [decorator] logging wrapped around any pricing, same interface
    static class Logged implements Pricing {
        private final Pricing inner;
        private final List<String> log;
        Logged(Pricing inner, List<String> log) { this.inner = inner; this.log = log; }
        public String name() { return inner.name(); }
        public int price(int minutes) {
            int p = inner.price(minutes);
            log.add(name() + " " + minutes + " min -> " + p + "p");
            return p;
        }
    }

    // [observer] whoever cares about a finished ride subscribes
    static class Rides {
        final List<BiFunction<String, Integer, String>> listeners = new ArrayList<>();
        List<String> end(String rider, int pence) {
            List<String> out = new ArrayList<>();
            for (BiFunction<String, Integer, String> fn : listeners) out.add(fn.apply(rider, pence));
            return out;
        }
    }

    record Trip(String rider, Pricing pricing, int minutes) {}

    public static void main(String[] args) {
        List<String> log = new ArrayList<>();
        Rides rides = new Rides();
        rides.listeners.add((rider, p) -> "billing: charged " + rider + " " + p + "p");
        rides.listeners.add((rider, p) -> "map: S-31 +1 bike");
        Vehicle bike = makeVehicle("e-bike", "E-205");
        System.out.println("[factory]   dock D7 released " + bike.kind() + " " + bike.vid());
        for (Trip t : List.of(new Trip("mia", new Member(), 42), new Trip("leo", new PayAsYouGo(), 18))) {
            int pence = new Logged(t.pricing(), log).price(t.minutes());
            System.out.println("[strategy]  " + t.rider() + ": " + t.pricing().name() + ", " + t.minutes() + " min -> " + pence + "p");
            System.out.println("[observer]  " + String.join(" | ", rides.end(t.rider(), pence)));
        }
        System.out.println("[decorator] log: " + String.join("; ", log));
    }
}

Output (the same in all three languages)

[factory]   dock D7 released e-bike E-205
[strategy]  mia: member, 42 min -> 120p
[observer]  billing: charged mia 120p | map: S-31 +1 bike
[strategy]  leo: pay-as-you-go, 18 min -> 280p
[observer]  billing: charged leo 280p | map: S-31 +1 bike
[decorator] log: member 42 min -> 120p; pay-as-you-go 18 min -> 280p

6. Pattern finder

Pattern finder

Tick what you see in your code. The finder suggests patterns and asks the question that matters first.

7. When patterns cost more than they save

8. How choosing goes wrong

9. Remember it and say it

In an interview or code review

• Lead with the change: "New pricing plans arrive monthly, so I'd make pricing a strategy." The reason comes before the name.
• Say what you didn't use, and why: "One notification channel today, so no bridge yet."
• Show combinations: strategies chosen by a factory, injected into the service.
• Be ready to remove one: if the variation disappears, simplify back.

10. Check yourself

11. Go deeper