Interview Q&A

• The NewsSubscriber class represents an observer. Each subscriber has a name

and implements the Update() method to receive news updates from the publisher.

public class NewsSubscriber : IObserver

private readonly string _name;

public NewsSubscriber(string name) => _name = name;

public void Update(string news) => Console.WriteLine($"{_name}

received news: {news}");

• Spreadsheet applications like Excel often use the Memento Pattern to save

different states of a spreadsheet, enabling the user to undo changes like

deleting a cell or modifying a formula.

Visual Diagram:

+----------------+ +--------------------+

| TextEditor | Save() | TextMemento |

| (Originator) |------------>| (Memento) |

+----------------+ +--------------------+

| ^

Write Text Restore

| |

v |

+----------------+ +--------------------+

| Caretaker |<------------| TextMemento |

| (History) | Undo() | (Memento) |

Follow:

+----------------+ +--------------------+

Conclusion:

The Memento Pattern is a powerful design pattern for handling state restoration in software

systems, especially when implementing undo functionality. It helps maintain encapsulation

while allowing objects to restore their previous states. Although it has potential drawbacks in

terms of memory usage and complexity, the Memento Pattern remains invaluable for

applications that require maintaining and reverting state, such as text editors, games, and

form-based applications.

Observer Pattern: Real-Time Example - News Feed System

Definition:

The Observer Pattern defines a one-to-many dependency between objects, where when

one object (the "subject") changes state, all its dependent objects (the "observers") are

notified and updated automatically. This pattern is often used in scenarios where an object’s

state changes frequently and multiple objects need to react to those changes, like a user

interface or event-driven systems.

Use Case:

A common use case of the Observer Pattern is a news feed where users (observers) need

to be notified whenever a new article (news) is published (state change). For example, in a

news publishing system, the publisher notifies all subscribers when a new news article is

published.

Code Breakdown:

Answer: The pattern enables the persistence of object states over time, which can be useful in applications like text editors, form submissions, or game states where you need to track changes and revert when needed. Considerations:

What interviewers expect

• A clear definition tied to GoF Patterns in Gang of Four Patterns projects
• Trade-offs (performance, maintainability, security, cost)
• When you would and would not use it in production

Real-world example

In a production Gang of Four Patterns application, teams apply this when handling user-facing features or integration boundaries. For example, you might use it during a sprint where reliability and observability matter—logging metrics, validating edge cases, and documenting the decision in an ADR so future developers understand why the approach was chosen.

How to explain in the interview

1. Define the concept in one or two sentences.
2. Context — where it fits in Gang of Four Patterns architecture.
3. Example — a specific project, bug, or performance win.
4. Trade-off — what you gain vs what you sacrifice.

Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.

• The caretaker calls Save() to store a Memento whenever the text is

changed. When an undo is triggered, the caretaker pops the most recent

Memento from the stack and asks the TextEditor to restore itself to the

state saved in that memento.

Benefits of the Memento Pattern:

Answer: In systems with different steps in a process, where each step has different behaviors and the system needs to transition between steps (e.g., approval process, document processing). Drawbacks of the State Pattern:

What interviewers expect

• A clear definition tied to GoF Patterns in Gang of Four Patterns projects
• Trade-offs (performance, maintainability, security, cost)
• When you would and would not use it in production

Real-world example

In a production Gang of Four Patterns application, teams apply this when handling user-facing features or integration boundaries. For example, you might use it during a sprint where reliability and observability matter—logging metrics, validating edge cases, and documenting the decision in an ADR so future developers understand why the approach was chosen.

How to explain in the interview

1. Define the concept in one or two sentences.
2. Context — where it fits in Gang of Four Patterns architecture.
3. Example — a specific project, bug, or performance win.
4. Trade-off — what you gain vs what you sacrifice.

Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.

Answer: By using a mediator to manage the interactions, it’s easier to change the behavior of the communication or add new features. The changes are contained within the mediator, and users don’t need to be modified. Real-Time Use Case Examples:

What interviewers expect

• A clear definition tied to GoF Patterns in Gang of Four Patterns projects
• Trade-offs (performance, maintainability, security, cost)
• When you would and would not use it in production

Real-world example

In a production Gang of Four Patterns application, teams apply this when handling user-facing features or integration boundaries. For example, you might use it during a sprint where reliability and observability matter—logging metrics, validating edge cases, and documenting the decision in an ADR so future developers understand why the approach was chosen.

How to explain in the interview

1. Define the concept in one or two sentences.
2. Context — where it fits in Gang of Four Patterns architecture.
3. Example — a specific project, bug, or performance win.
4. Trade-off — what you gain vs what you sacrifice.

Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.

• In game development, game objects like enemies, obstacles, and power-ups

can be stored in collections. The Iterator Pattern can be used to iterate over

these objects, processing each object individually without exposing the

underlying collection implementation.

Improvements and Considerations:

Answer: Multiple iterators can be created to traverse the collection at the same time. This means that different parts of the program can independently iterate over the collection without interfering with each other.

What interviewers expect

• A clear definition tied to GoF Patterns in Gang of Four Patterns projects
• Trade-offs (performance, maintainability, security, cost)
• When you would and would not use it in production

Real-world example

In a production Gang of Four Patterns application, teams apply this when handling user-facing features or integration boundaries. For example, you might use it during a sprint where reliability and observability matter—logging metrics, validating edge cases, and documenting the decision in an ADR so future developers understand why the approach was chosen.

How to explain in the interview

1. Define the concept in one or two sentences.
2. Context — where it fits in Gang of Four Patterns architecture.
3. Example — a specific project, bug, or performance win.
4. Trade-off — what you gain vs what you sacrifice.

Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.

• In cases where complex actions need to be performed on the abstract syntax

tree (AST) (e.g., optimization or transformation), combining the Interpreter

Pattern with the Visitor Pattern can allow you to apply operations across

different types of expressions in a structured way.

Visual Diagram:

+-----------------------------+

| IExpression |

| (Abstract Expression) |

+-----------------------------+

Follow:

+------------------------------------+

| |

+-------------------+

+------------------+

| Number | | Add

| (Terminal Exp.) | | (Non-Terminal

Exp.) |

+-------------------+

+------------------+

| |

| |

(Interprets to a value) (Interprets to

sum of left + right)

Conclusion:

The Interpreter Pattern provides a robust and flexible way to interpret and evaluate

expressions, particularly when the grammar is dynamic or complex. By breaking down the

grammar into terminal and non-terminal expressions, it allows for recursive evaluation, which

is ideal for use cases such as mathematical expression parsing, query processing, or

language parsing. The pattern is extendable, allowing for easy addition of new operations,

and can be optimized for more complex scenarios with careful management of resources.

Iterator Pattern: Real-Time Example - Iterating Over a Collection of

Products

Definition:

The Iterator Pattern provides a way to access the elements of an aggregate object (like a

collection) sequentially without exposing its underlying representation. It allows for traversal

of the collection without needing to know the details of how the data is stored internally.

Use Case:

A typical use case for the Iterator Pattern is iterating over a collection of items, such as a

list of products or any other data structure like arrays, lists, or trees. It allows a client to

traverse through the collection's elements without needing direct access to the internal

structure.

Follow:

Code Explanation:

Follow:

• Configuration files (e.g., JSON, XML, or custom formats) can be parsed using

the Interpreter Pattern. Each element or configuration setting can be treated

as an expression, and the pattern allows for flexible and extensible parsing

rules.

Improvement Suggestions:

• Each type of expression (terminal or non-terminal) is encapsulated in its own

class, adhering to the Single Responsibility Principle. This separation

ensures that each class has a well-defined role in the expression evaluation

process.

Real-Time Use Case Examples:

directly returns the number it holds.

What interviewers expect

• A clear definition tied to GoF Patterns in Gang of Four Patterns projects
• Trade-offs (performance, maintainability, security, cost)
• When you would and would not use it in production

Real-world example

In a production Gang of Four Patterns application, teams apply this when handling user-facing features or integration boundaries. For example, you might use it during a sprint where reliability and observability matter—logging metrics, validating edge cases, and documenting the decision in an ADR so future developers understand why the approach was chosen.

How to explain in the interview

1. Define the concept in one or two sentences.
2. Context — where it fits in Gang of Four Patterns architecture.
3. Example — a specific project, bug, or performance win.
4. Trade-off — what you gain vs what you sacrifice.

Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.

• In simulations (e.g., a large number of agents in a traffic simulation or

animals in an ecosystem), the Flyweight Pattern can be used to share

common behaviors or attributes across many instances, reducing memory

overhead.

Improvement Suggestions:

Follow:

Answer: that the flyweight (e.g., the Character object) is only created once per unique symbol, and all subsequent requests for the same symbol reuse the existing instance.

What interviewers expect

• A clear definition tied to GoF Patterns in Gang of Four Patterns projects
• Trade-offs (performance, maintainability, security, cost)
• When you would and would not use it in production

Real-world example

In a production Gang of Four Patterns application, teams apply this when handling user-facing features or integration boundaries. For example, you might use it during a sprint where reliability and observability matter—logging metrics, validating edge cases, and documenting the decision in an ADR so future developers understand why the approach was chosen.

How to explain in the interview

1. Define the concept in one or two sentences.
2. Context — where it fits in Gang of Four Patterns architecture.
3. Example — a specific project, bug, or performance win.
4. Trade-off — what you gain vs what you sacrifice.

Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.

• In UI libraries, a Factory Method can be used to create various types of UI

components (e.g., buttons, text fields) that can differ based on the platform

(e.g., Windows vs. macOS). A factory method ensures the correct UI

components are created for the targeted platform.

Improvement Suggestions:

Answer: By keeping the logic separate from the elements, the code is easier to maintain and extend, since new behaviors are added in visitor classes rather than modifying the core objects. When to Use the Visitor Pattern:

What interviewers expect

• A clear definition tied to GoF Patterns in Gang of Four Patterns projects
• Trade-offs (performance, maintainability, security, cost)
• When you would and would not use it in production

Real-world example

In a production Gang of Four Patterns application, teams apply this when handling user-facing features or integration boundaries. For example, you might use it during a sprint where reliability and observability matter—logging metrics, validating edge cases, and documenting the decision in an ADR so future developers understand why the approach was chosen.

How to explain in the interview

1. Define the concept in one or two sentences.
2. Context — where it fits in Gang of Four Patterns architecture.
3. Example — a specific project, bug, or performance win.
4. Trade-off — what you gain vs what you sacrifice.

Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.

• The client code does not need to know which logger is being used. It interacts

with the factory (e.g., ConsoleLoggerFactory), which produces the

desired logger. This decouples the client code from the concrete logging

classes, promoting flexibility and scalability.

Key Benefits of the Factory Method Pattern:

Answer: In a banking application, a facade could simplify processes such as transferring funds, managing accounts, and checking balances, so that users don’t need to manually handle every step of the transaction. Improvement Suggestions:

What interviewers expect

• A clear definition tied to GoF Patterns in Gang of Four Patterns projects
• Trade-offs (performance, maintainability, security, cost)
• When you would and would not use it in production

Real-world example

In a production Gang of Four Patterns application, teams apply this when handling user-facing features or integration boundaries. For example, you might use it during a sprint where reliability and observability matter—logging metrics, validating edge cases, and documenting the decision in an ADR so future developers understand why the approach was chosen.

How to explain in the interview

1. Define the concept in one or two sentences.
2. Context — where it fits in Gang of Four Patterns architecture.
3. Example — a specific project, bug, or performance win.
4. Trade-off — what you gain vs what you sacrifice.

Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.

Answer: Clients don’t need to know about the specific classes that make up the subsystem. The facade hides this information, reducing dependencies and improving modularity. Real-Time Use Case Examples:

What interviewers expect

• A clear definition tied to GoF Patterns in Gang of Four Patterns projects
• Trade-offs (performance, maintainability, security, cost)
• When you would and would not use it in production

Real-world example

In a production Gang of Four Patterns application, teams apply this when handling user-facing features or integration boundaries. For example, you might use it during a sprint where reliability and observability matter—logging metrics, validating edge cases, and documenting the decision in an ADR so future developers understand why the approach was chosen.

How to explain in the interview

1. Define the concept in one or two sentences.
2. Context — where it fits in Gang of Four Patterns architecture.
3. Example — a specific project, bug, or performance win.
4. Trade-off — what you gain vs what you sacrifice.

Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.

Answer: The Decorator Pattern can be used to extend the functionality of media streaming services. For example, you could decorate a base video stream to include ads, subtitles, or additional features like HD quality. Improvement Suggestions:

What interviewers expect

• A clear definition tied to GoF Patterns in Gang of Four Patterns projects
• Trade-offs (performance, maintainability, security, cost)
• When you would and would not use it in production

Real-world example

In a production Gang of Four Patterns application, teams apply this when handling user-facing features or integration boundaries. For example, you might use it during a sprint where reliability and observability matter—logging metrics, validating edge cases, and documenting the decision in an ADR so future developers understand why the approach was chosen.

How to explain in the interview

1. Define the concept in one or two sentences.
2. Context — where it fits in Gang of Four Patterns architecture.
3. Example — a specific project, bug, or performance win.
4. Trade-off — what you gain vs what you sacrifice.

Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.

• The beauty of the Decorator Pattern is that new features (like milk or sugar)

can be added dynamically, without changing the original SimpleCoffee

class. You can stack decorators as needed, allowing for flexible and

extensible object behavior at runtime.

Key Benefits of the Decorator Pattern:

• Operations like searching for a file or calculating the total size of a directory

could be added to the IFileSystemComponent interface and implemented

by both files and directories.

Visual Diagram:

Here's a simple visual diagram to understand the Composite Pattern:

+----------------------+

| IFileSystemComponent |

+----------------------+

/ \

/ \

+-----------+ +-----------+

| File | | Directory |

+-----------+ +-----------+

/ \

/ \

+-----------+ +-----------+

| File | | Directory |

+-----------+ +-----------+

• File and Directory both implement IFileSystemComponent.
• A Directory can contain multiple File objects or other Directory objects.

Conclusion:

The Composite Pattern is an effective design pattern for dealing with tree-like structures,

where individual objects and composites need to be treated uniformly. In real-time

applications like file systems, graphic design tools, and organizational hierarchies, this

pattern simplifies the client code and allows for flexible and scalable solutions. By using this

Follow:

pattern, you can easily manage complex structures and extend them with new types of

components as your system grows.

Decorator Pattern: Real-Time Example - Enhancing a Coffee Order

Scenario:

The Decorator Pattern is used to add new behaviors or responsibilities to objects

dynamically without affecting the behavior of other objects in the system. It’s perfect when

you want to extend or change the functionality of an object at runtime without altering its

original code.

Use Case:

A common example is a coffee order where you can add extra features such as milk, sugar,

or even whipped cream to a basic coffee without modifying the original Coffee class.

Code Explanation:

• The client code (in this case, the Program class) doesn’t need to worry about

whether a component is a file or a directory. It can just call ShowInfo() on

any component and let the pattern take care of the rest.

Follow:

Real-Time Use Case Example:

• The ShowInfo() method in Directory calls ShowInfo() on all its child

components. This is where the recursive nature of the Composite Pattern

comes into play. It doesn’t matter whether the child is a File or another

Directory; both types implement the ShowInfo() method, and the

directory simply iterates over its children.

Key Benefits of the Composite Pattern:

Answer: The Command Pattern allows commands to be queued for execution, making it suitable for scenarios where requests need to be delayed or processed sequentially, such as in transaction management or job scheduling. Improvement Suggestions:

What interviewers expect

• A clear definition tied to GoF Patterns in Gang of Four Patterns projects
• Trade-offs (performance, maintainability, security, cost)
• When you would and would not use it in production

Real-world example

In a production Gang of Four Patterns application, teams apply this when handling user-facing features or integration boundaries. For example, you might use it during a sprint where reliability and observability matter—logging metrics, validating edge cases, and documenting the decision in an ADR so future developers understand why the approach was chosen.

How to explain in the interview

1. Define the concept in one or two sentences.
2. Context — where it fits in Gang of Four Patterns architecture.
3. Example — a specific project, bug, or performance win.
4. Trade-off — what you gain vs what you sacrifice.

Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.