Open/closed through the strategy pattern

A cordless screwdriver takes interchangeable bits in one hex socket, and a case beside it holds the bits for the job.

At the workbench	In code
the hex socket takes any bit with the standard shank	one interface every strategy implements (step 2)
a job with a new screw head needs one more bit; the screwdriver is never opened	a variant added beside an unchanged core (steps 1, 6)
a screwdriver with three tips on a turning collar needs a new collar for a fourth head	a switch, reopened by each variant (step 4)
the case has a labelled slot for every head on the job list, so a missing bit shows as an empty slot	a registry typed by the union (steps 5, 7)
a torque chart taped to the handle, one row per head, needs a row for each new head as well	a second table keyed by the kind (step 9)
the person on the job picks the bit; the screwdriver never does	the context does not choose (steps 3, 13)
a homeowner who only meets slotted and cross-head screws keeps one two-ended screwdriver	a small, stable switch (step 11)

In real terms: a strategy is an object or a function the core calls through one interface; the registry is the one place that lists the kinds, and the union is the list the compiler checks it against.

Breaks down when: anyone can see an empty slot. In TypeScript only a registry typed by the union shows a missing entry; a Map hides it until a lookup runs (step 8).

Contrasting case: a workshop that drives one kind of screw all day has nothing to swap: one algorithm needs no strategy.

4.1 ExamHall EXH-2550: drag-order in the scoring switch

ExamHall's score() held one switch over the question types. The drag-order type arrived:

// types.ts
export type QuestionType = 'mcq' | 'multi' | 'numeric' | 'essay';
export interface Question { id: string; type: QuestionType; key: string }

// grade.ts
import type { Question } from './types';
export function score(q: Question, answer: string): number {
  switch (q.type) {
    case 'mcq': return answer === q.key ? 1 : 0;
    case 'multi': return answer.split(',').sort().join(',') === q.key ? 2 : 0;
    case 'numeric': return Math.abs(Number(answer) - Number(q.key)) <= 0.01 ? 1 : 0;
    case 'essay': return 0; // marked by a person later
  }
}

4.1 EXH-2550 switch design, drag-order added the smallest way: types.ts 1 line, grade.ts 1 line (a case in score) · grading test 5 of 5

The new type opened grade.ts, the code every type runs through (step 4).

4.2 MR !2850: the scoring switch as a registry

MR !2850 moves each case into a class behind one Scorer interface, registers the classes, and leaves grade.ts a single lookup:

// scorer.ts
import type { Question } from './types';
export interface Scorer { score(q: Question, answer: string): number; }

// mcq.ts (multi.ts, numeric.ts, essay.ts and drag-order.ts hold the other cases the same way)
import type { Scorer } from './scorer';
import type { Question } from './types';
export class Mcq implements Scorer { score(q: Question, answer: string) { return answer === q.key ? 1 : 0; } }

// registry.ts
import type { QuestionType } from './types';
import type { Scorer } from './scorer';
import { Mcq } from './mcq';
// … one import per class
export const scorers: Record<QuestionType, Scorer> = { mcq: new Mcq(), multi: new Multi(), numeric: new Numeric(), essay: new Essay(), 'drag-order': new DragOrder() };

// grade.ts
import type { Question } from './types';
import { scorers } from './registry';
export const score = (q: Question, answer: string): number => scorers[q.type].score(q, answer);

4.2 MR !2850 registry design: grading test 5 of 5, as on the switch (5 of 5) · grade.ts names no question type
4.2 MR !2850 then hotspot added the smallest way: types.ts 1 line, registry.ts 2 lines · new hotspot.ts · grade.ts 0 lines · grading test 6 of 6

The grading tests give the same scores before and after, and the next type, hotspot, arrives beside grade.ts without opening it (steps 5–6).