Template Method pattern in LLD - System Design Exercise

Design: Template Method Pattern Implementation

Design and implement the Template Method pattern focusing on class structure and method overriding. Out of scope are specific application domains or UI implementations.

Functional Requirements

FR1: Define a base algorithm structure with fixed steps.

FR2: Allow subclasses to override certain steps without changing the algorithm's structure.

FR3: Ensure the algorithm steps are executed in a specific order.

FR4: Support reuse of common code in the base class.

FR5: Allow easy extension for new variations of the algorithm.

Non-Functional Requirements

NFR1: The base algorithm structure must remain unchanged by subclasses.

NFR2: Subclasses can only override specific steps, not the entire algorithm.

NFR3: The design should promote code reuse and avoid duplication.

NFR4: The solution should be easy to understand and maintain.

Think Before You Design

Questions to Ask

❓ Question 1

❓ Question 2

❓ Question 3

❓ Question 4

❓ Question 5

Key Components

Abstract base class defining the template method and abstract steps

Concrete subclasses overriding specific steps

Hook methods for optional steps

Method visibility (protected/private) to control overriding

Design Patterns

Template Method pattern

Inheritance and polymorphism

Hook methods

Open/Closed Principle

Reference Architecture

  +---------------------+
  | AbstractAlgorithm   |
  |---------------------|
  | + templateMethod()   |  <--- fixed algorithm steps order
  | # step1()           |  <--- abstract step
  | # step2()           |  <--- abstract step
  | # hook()            |  <--- optional step
  +----------+----------+
             |
             |
  +----------+----------+
  | ConcreteAlgorithmA   |
  |---------------------|
  | + step1() override  |
  | + step2() override  |
  | + hook() override?  |
  +---------------------+

  +---------------------+
  | ConcreteAlgorithmB   |
  |---------------------|
  | + step1() override  |
  | + step2() override  |
  +---------------------+

Components

AbstractAlgorithm

Abstract class or interface

Defines the template method with fixed step order and declares abstract steps to be implemented by subclasses.

ConcreteAlgorithmA

Subclass

Implements specific steps of the algorithm by overriding abstract methods.

ConcreteAlgorithmB

Subclass

Another variation implementing different steps.

Request Flow

1. Client calls templateMethod() on an instance of a concrete subclass.

2. templateMethod() executes steps in fixed order: step1(), step2(), hook().

3. Each step calls the subclass's overridden method if provided.

4. Optional hook() method can be overridden or left empty.

5. Algorithm completes after all steps execute in order.

Database Schema

Not applicable for this design pattern focused on class structure and behavior.

Scaling Discussion

Bottlenecks

Adding many subclasses can increase maintenance complexity.

If steps need to change order dynamically, pattern is less flexible.

Overriding too many steps may lead to duplicated code across subclasses.

Solutions

Use composition or strategy pattern if dynamic step order is needed.

Extract common code into helper methods to reduce duplication.

Limit subclass responsibilities to only necessary step overrides.

Document template method clearly to avoid misuse.

Interview Tips

Time: Spend 10 minutes explaining the pattern concept and problem it solves, 15 minutes designing the class structure and method flow, 10 minutes discussing pros, cons, and scaling.

Explain fixed algorithm structure with customizable steps.

Show how inheritance and method overriding enable reuse.

Discuss how template method enforces step order.

Mention optional hooks for flexibility.

Highlight benefits like code reuse and easier maintenance.

Discuss limitations and when to use alternative patterns.

Practice

1. What is the main purpose of the Template Method pattern in system design?

easy

A. To replace all methods with completely new implementations

B. To define a fixed sequence of steps with some customizable parts

C. To allow direct modification of the entire process by subclasses

D. To create multiple unrelated classes with no shared behavior

Solution

1. Step 1: Understand the Template Method pattern goal

   The pattern fixes the overall process flow but allows subclasses to customize certain steps.

2. Step 2: Analyze each option

   To define a fixed sequence of steps with some customizable parts correctly describes this fixed sequence with customizable parts. Options A, B, and C do not match the pattern's intent.

3. Final Answer:

   To define a fixed sequence of steps with some customizable parts -> Option B

4. Quick Check:

   Template Method = fixed process + flexible steps [OK]

Hint: Remember: fixed order, flexible details [OK]

Common Mistakes:

• Thinking subclasses rewrite the whole process
• Confusing Template Method with Strategy pattern
• Believing the pattern removes all common code
• Assuming no steps are customizable

2. Which of the following is the correct way to declare a template method in a class?

easy

A. Override all methods in subclasses without calling base methods

B. Define multiple unrelated methods without calling each other

C. Define a method that calls other methods in a fixed order

D. Use a method that randomly calls other methods

Solution

1. Step 1: Identify the structure of a template method

   A template method is a method that defines the sequence of steps by calling other methods in order.

2. Step 2: Evaluate each option

   Define a method that calls other methods in a fixed order matches this definition. Options B, C, and D do not follow the fixed sequence concept.

3. Final Answer:

   Define a method that calls other methods in a fixed order -> Option C

4. Quick Check:

   Template method = fixed calls order [OK]

Hint: Template method calls steps in order [OK]

Common Mistakes:

• Not calling methods in a fixed sequence
• Overriding template method instead of steps
• Ignoring the fixed process structure
• Using random or unordered calls

3. Consider this simplified template method code in Python:

class Game:
    def play(self):
        self.start()
        self.play_turn()
        self.end()

    def start(self):
        print('Game started')

    def play_turn(self):
        print('Playing turn')

    def end(self):
        print('Game ended')

class Chess(Game):
    def play_turn(self):
        print('Chess turn played')

chess = Chess()
chess.play()

What will be the output when chess.play() is called?

medium

A. Game ended
Chess turn played
Game started

B. Chess turn played
Game started
Game ended

C. Game started
Playing turn
Game ended

D. Game started
Chess turn played
Game ended

Solution

1. Step 1: Trace the play() method calls

   The play() method calls start(), play_turn(), and end() in order.

2. Step 2: Identify overridden methods

   Chess overrides play_turn(), so Chess's version prints 'Chess turn played'. start() and end() use base class prints.

3. Final Answer:

   Game started Chess turn played Game ended -> Option D

4. Quick Check:

   Template calls base start/end + overridden play_turn [OK]

Hint: Overridden steps print their own messages [OK]

Common Mistakes:

• Ignoring method overriding
• Assuming base play_turn() runs
• Mixing order of prints
• Thinking play() is overridden

4. In the following code, what is the main problem that breaks the Template Method pattern?

class Report:
    def generate(self):
        self.load_data()
        self.process_data()
        self.save_report()

    def load_data(self):
        print('Loading data')

    def process_data(self):
        print('Processing data')

    def save_report(self):
        print('Saving report')

class CustomReport(Report):
    def generate(self):
        print('Custom generate start')
        self.load_data()
        self.process_data()
        self.save_report()
        print('Custom generate end')

medium

A. The subclass overrides the template method instead of steps

B. The base class does not define any methods

C. The subclass does not call any base methods

D. The base class methods are private

Solution

1. Step 1: Identify the template method and overrides

   The base class defines generate() as the template method. The subclass overrides generate() itself.

2. Step 2: Understand Template Method pattern rules

   In this pattern, subclasses should override steps, not the template method, to keep the fixed process intact.

3. Final Answer:

   The subclass overrides the template method instead of steps -> Option A

4. Quick Check:

   Template method must not be overridden [OK]

Hint: Override steps, not the template method [OK]

Common Mistakes:

• Overriding the whole template method
• Ignoring base class method definitions
• Assuming private methods cause issues
• Thinking subclass must call base generate() explicitly

5. You are designing a document processing system where each document type requires a specific sequence of steps: open, parse, validate, save, and close. You want to ensure the sequence is fixed but allow each document type to customize parsing and validation. How should you apply the Template Method pattern here?

hard

A. Create a base class with a template method calling open, parse, validate, save, close; subclasses override parse and validate

B. Let each subclass implement its own full process without a base class

C. Use separate unrelated classes for each step without a fixed sequence

D. Make all steps abstract and force subclasses to implement the entire process

Solution

1. Step 1: Identify fixed and customizable parts

   The sequence (open, parse, validate, save, close) is fixed; parse and validate vary by document type.

2. Step 2: Apply Template Method pattern correctly

   Create a base class with a template method that calls all steps in order. Subclasses override parse and validate to customize behavior.

3. Final Answer:

   Create a base class with a template method calling open, parse, validate, save, close; subclasses override parse and validate -> Option A

4. Quick Check:

   Fixed sequence + customizable steps = Template Method [OK]

Hint: Fix sequence in base; override variable steps in subclasses [OK]

Common Mistakes:

• Not fixing the sequence in one place
• Forcing subclasses to rewrite entire process
• Ignoring the need for a template method
• Separating steps without order control