Composition over inheritance, and the fragile base class

Head office issues a card for every drink, and one franchise café writes its own "extra strong" card on top of them.

At the café	In code
the franchise card adds a shot to every espresso and a shot to every flat white	a subclass adding work to two methods (steps 1 and 3)
head office rewrites the flat white card to start from its espresso card; the franchise's flat whites now get two extra shots, though its own card never changed	a self-call reaching the override, after a base release (steps 2–5)
another café adds its extra shot at the hand-off counter, once per cup, whatever the card does inside	forwarding: the wrapper's work runs once per call (step 7)
the order slip has separate boxes for size, milk and extra shot; an oat-milk large with an extra shot is ticked boxes, not a new card	injected parts: a combination is arguments (steps 9–10)
the lid-sealing machine takes only the chain's own cups, however alike another cup looks	extend where the class is checked (step 13)

In real terms: a subclass shares its base's methods and runs its overrides inside them; a wrapper or a service with injected parts only calls what it holds.

Breaks down when: the barista reads the new card and stops at the second extra shot. Code runs both overrides without a pause; only a test that counts notices.

Contrasting case: a kiosk that sells one drink in one size has no extra shot to add and nothing to combine, so neither choice has work to do.

4.1 ExamHall EXH-2670: a reconnect that looked like typing

The proctor console's activity feed extends the attempts package's Attempt, whose changed hook runs after each answer:

// attempt.ts (@examhall/attempts)
export class Attempt {
  answers = new Map<string, string>();
  answer(q: string, text: string): void { this.answers.set(q, text); this.changed(q); }
  restore(saved: [string, string][]): void { for (const [q, text] of saved) this.answer(q, text); }
  protected changed(q: string): void {}
}

// tracked-attempt.ts (the proctor console)
import { Attempt } from './attempt';
export class TrackedAttempt extends Attempt {
  feed: string[] = [];
  protected changed(q: string): void { this.feed.push(`edited ${q}`); }
}

4.1 EXH-2670 a reconnect restores 3 saved answers: feed "edited q1, edited q2, edited q3" · the candidate typed none of them
4.1 EXH-2670 one answer the candidate types: feed "edited q4" · tsc no diagnostics

restore reuses answer, so the override ran for every restored answer, and the proctor saw edits the candidate never made (steps 2 and 4).

4.2 ExamHall EXH-2671 and MR !2970: the fifth exam type as a combination

ExamHall's exam types were a base class and three subclasses, and the exam board asked for a proctored practice exam:

// exams.ts (before MR !2970)
export class BaseExam { start(): string[] { return ['load questions']; } }
export class TimedExam extends BaseExam { start(): string[] { return [...super.start(), 'deadline in 60 min']; } }
export class ProctoredExam extends TimedExam { start(): string[] { return [...super.start(), 'webcam on']; } }
export class PracticeExam extends BaseExam { start(): string[] { return [...super.start(), 'answers shown after each question']; } }

4.2 EXH-2671 before: 4 classes · a fifth class extending ProctoredExam starts "load questions, deadline in 60 min, webcam on, answers shown after each question"
4.2 EXH-2671 a fifth class extending PracticeExam instead starts "load questions, answers shown after each question, webcam on" · the webcam step is then written in 2 classes

MR !2970 turns each axis into a part that the service is given:

// exam-service.ts (MR !2970)
export interface Part { start(steps: string[]): void }
export class ExamService {
  constructor(private parts: Part[]) {}
  start(): string[] { const steps = ['load questions']; for (const p of this.parts) p.start(steps); return steps; }
}
export const deadline = (min: number): Part => ({ start: (s) => { s.push(`deadline in ${min} min`); } });
export const webcam: Part = { start: (s) => { s.push('webcam on'); } };
export const showAnswers: Part = { start: (s) => { s.push('answers shown after each question'); } };

// the proctored practice exam
export const proctoredPractice = new ExamService([webcam, showAnswers]);

4.2 MR !2970 the 3 existing types from parts: the same start steps as their classes (3 of 3)
4.2 MR !2970 proctoredPractice starts "load questions, webcam on, answers shown after each question" · classes added for it 0 · tsc no diagnostics
4.2 MR !2970 every mix of the 3 parts, each in or out: 8 exam types, 8 distinct start-step lists, from 3 parts and no class per mix

Before, the new type had to extend one parent and copy the other's step (step 8); after, it is one more list of the same parts, and three parts cover all eight mixes (steps 9–10).