Template Method — Algorithmics

Three report generators. Each one fetches rows, formats them, and returns a string — surrounded by identical retry logic, identical timing, and identical error wrapping.

What people write first

Copy the pipeline, change the two lines that differ.

class CsvReport {
  async run() {
    const started = Date.now();
    for (let attempt = 0; ; attempt++) {
      try {
        const rows = await db.query(CSV_SQL);      // ← differs
        const body = toCsv(rows);                  // ← differs
        metrics.timing("report", Date.now() - started);
        return body;
      } catch (e) {
        if (attempt >= 2) throw new ReportFailed(e);
      }
    }
  }
}

// …and PdfReport, and JsonReport, each with the same 12 lines around it.

The retry, the timing and the error wrapping are duplicated. Fix a bug in one and the other two keep it.

Twelve lines duplicated three times. It works until the retry limit changes, or someone discovers the metric name is wrong, and the fix lands in one of the three.

The pattern

Write the sequence once, in a method nobody overrides. Leave holes.

abstract class Report {
  /** The skeleton. Not overridable — that is the whole idea. */
  async run(): Promise<string> {
    const started = Date.now();

    for (let attempt = 0; ; attempt += 1) {
      try {
        const body = this.format(await this.fetch());
        metrics.timing('report', Date.now() - started);
        return body;
      } catch (error) {
        if (attempt >= 2) throw new ReportFailed(error);
      }
    }
  }

  // The holes. A subclass must fill both.
  protected abstract fetch(): Promise<Row[]>;
  protected abstract format(rows: Row[]): string;
}

class CsvReport extends Report {
  protected fetch() { return db.query(CSV_SQL); }
  protected format(rows: Row[]) { return toCsv(rows); }
}

Hooks: the optional holes

Not every step must be mandatory. A hook is a step with a default the subclass may override:

abstract class Report {
  async run() { /* … */ }

  protected abstract fetch(): Promise<Row[]>;
  protected abstract format(rows: Row[]): string;

  /** Hook: most reports do not need this. */
  protected shouldCache(): boolean { return true; }
}

Keep abstract methods for what genuinely varies and hooks for what occasionally does. A base class with eight hooks is a base class that does not know what it is.

Never call an overridable method from a constructor

abstract class Report {
  private readonly rows: Row[];
  constructor() { this.rows = this.defaultRows(); }   // ← runs before the subclass exists
  protected defaultRows(): Row[] { return []; }
}

class CsvReport extends Report {
  private limit = 100;
  protected defaultRows() { return take(ALL, this.limit); }   // limit is undefined here
}

The base constructor runs first, so the override executes before the subclass’s own fields are initialised. this.limit is undefined, and take(ALL, undefined) silently returns nothing.

Same trap in Java and C#. It is one of the strongest arguments for composition over inheritance, because the equivalent bug is not expressible with an injected object.

Where it runs out

Inheritance gives you one axis of variation, chosen at compile time.

Two independent axes — three fetch strategies × three formats — means nine subclasses. That is the class explosion again, and the answer is the same as it was for Decorator: compose instead.

class Report {
  constructor(
    private readonly fetch: () => Promise<Row[]>,
    private readonly format: (rows: Row[]) => string,
  ) {}

  async run(): Promise<string> { /* identical skeleton */ }
}

new Report(csvQuery, toCsv);
new Report(csvQuery, toPdf);        // any combination, no new class

Same skeleton, same guarantee that the retry runs, and the pieces mix freely. This is Strategy — and the honest summary is that Template Method is Strategy done with inheritance, appropriate when there is exactly one axis and the steps are genuinely internal to the algorithm.