/** * Adapter — a thin object presenting one interface in the vocabulary of * another. */ // What the rest of the museum's code has agreed to talk to. interface Clock { now(): string; } // What it actually has: something older, with its own manners, which cannot // be changed because it is not ours. class LegacyTimer { getEpochMillis(): number { return 1_700_000_000_000; } } class LegacyTimerAdapter implements Clock { constructor(private readonly timer: LegacyTimer) {}

/** * Proxy — an object standing where another would, deciding what to pass on. */ const engine = { start(): string { return "running"; }, secretKey: "hunter2", }; // The language provides the pattern. This proxy was never told what shape // `engine` is, and will not need telling when that shape changes. const guarded = new Proxy(engine, { get(target, property, receiver) { if (property === "secretKey") { throw new Error("not yours"); } return Reflect.get(target, property, receiver); }, });

/** * Chain of Responsibility — each handler decides whether to answer, or to * pass the request along and do something with what comes back. */ type Request = { path: string; user?: string }; type Next = () => string; type Middleware = (request: Request, next: Next) => string; const logging: Middleware = (request, next) => { console.log("-> " + request.path); return next(); }; const auth: Middleware = (request, next) => request.user ? next() : "401 unauthorised"; const route: Middleware = (request) => "200 " + request.path; function chain(middlewares: Middleware[]): (request: Request) => string { return (request) => {

/** * Builder — construction spread across named steps, ending in one finished * object. */ class QueryBuilder { private readonly columns: string[] = []; private readonly conditions: string[] = []; private max?: number; constructor(private readonly table: string) {} // Each step returns `this`, which is the whole of the fluent interface. select(...columns: string[]): this { this.columns.push(...columns); return this; } where(condition: string): this { this.conditions.push(condition); return this;

Commissioned for this museum · after Gamma, Helm, Johnson & Vlissides, 1994

Facade

TypeScript·1994·36 lines·770 bytes

/**
 * Facade — one small surface in front of several larger ones.
 */
class Oven {
	heatTo(celsius: number): void {
		console.log("oven at " + celsius + "C");
	}
}

class Mixer {
	mix(what: string): void {
		console.log("mixing " + what);
	}
}

class Timer {
	ring(minutes: number): void {
		console.log("ring in " + minutes + " min");
	}
}

class Kitchen {
	private readonly oven = new Oven();
	private readonly mixer = new Mixer();
	private readonly timer = new Timer();

	// One method, because one method is what almost every caller wants. The
	// oven, mixer and timer are still there for the caller who does not.
	bakeBread(): void {
		this.mixer.mix("flour, water, salt, yeast");
		this.oven.heatTo(220);
		this.timer.ring(35);
	}
}

new Kitchen().bakeBread();

Curator’s note

A facade is not a wrapper. A wrapper covers everything underneath and forwards it; a facade covers the one path almost everybody wants and leaves the rest visible. The difference is a judgement about your callers, and it is the only judgement this pattern asks you to make: what is the common case, and is it common enough to deserve a name?

That judgement is also where facades go wrong. bakeBread is a good one because bread is genuinely what most people came for. The failure mode is a facade that keeps growing — a parameter for the temperature, then one for the rise time, then an options object with eleven fields — until it is the subsystem again with an extra layer of indirection in front of it. At that point it has stopped simplifying anything and started costing a hop. A facade that has to expose everything underneath was the wrong shape to begin with.

The name is architectural and the metaphor is exact. A facade on a building is the face it shows the street: it is not the building, it does not pretend to be the building, and nobody is confused about whether there are rooms behind it. The moment a facade tries to *be* the subsystem rather than present it, it becomes a wall — and walls get doors cut into them later, by people who are annoyed about it.

The version worth having is the one you could delete in an afternoon, because everything it calls is still reachable without it.

Elsewhere in the museum

LectureWhat abstraction costs
LectureWhy programs are hard to change

Hall of Composition

Hall of Composition

Facade

Curator’s note

Elsewhere in the museum