Interview Q&A

Answer: Each time the Change method is called, the current state will perform its action and then set the next state, allowing the traffic light to cycle through its states (Red → Green → Yellow → Red). Benefits 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.

• The Singleton Pattern makes it harder to extend or inherit the class due to its

static nature.

Conclusion:

The Singleton Pattern is a powerful tool for ensuring that a class has only one instance and

provides a global access point to that instance. It's useful for managing shared resources

like configuration settings, logging, or caching. However, care should be taken when using it,

especially in multi-threaded applications, and consideration should be given to the

challenges in testing and extending the class.

State Pattern: Allowing Object Behavior to Change Based on Its State

Definition:

The State Pattern allows an object to change its behavior when its internal state changes.

The object will appear to change its class. It's used when an object's behavior is dependent

on its state and the object needs to behave differently in different states without using

complex conditionals.

Use Case:

The State Pattern is useful in scenarios where an object's behavior is conditional on its

state. A typical use case is a traffic light system where the behavior (light change) varies

based on the current state (Red, Green, Yellow).

Code Breakdown:

• This is a more advanced form of lazy initialization that avoids the performance

overhead of locking once the instance has been created.

public class Singleton
{
private static Singleton _instance;
private static readonly object _lock = new object();
private Singleton() { }
public static Singleton Instance
{

get

{
if (_instance == null)
{

lock (_lock)

{
if (_instance == null)
{
_instance = new Singleton();
}
}
}
return _instance;
}
}
}

Answer: The pattern provides a global access point to the instance, allowing all parts of the application to access the same object without the need for passing references. When to Use the Singleton 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.

• A proxy could manage the interaction with external web services, controlling

when to send requests and how to handle responses. It can also perform

additional checks like authentication or caching.

Conclusion:

The Proxy Pattern is an excellent design pattern to control access to expensive or sensitive

objects. Whether it's controlling resource initialization (virtual proxy), managing remote

communication (remote proxy), or handling access control (protective proxy), proxies enable

efficient resource management and enhance security in an application.

Singleton Pattern: Ensuring a Single Instance

Definition:

Follow:

The Singleton Pattern ensures that a class has only one instance throughout the lifetime of

an application and provides a global point of access to that instance. It's often used for

managing shared resources, like configuration settings, logging, or database connections.

Use Case:

The Singleton Pattern is useful when you need to control access to a shared resource or

configuration. For example, when managing global configuration settings or database

connections, it ensures that the configuration or connection is accessed by all parts of the

application via a single, consistent instance.

Code Breakdown:

Answer: Stores the results of expensive operations and returns cached results for subsequent requests, improving performance by avoiding redundant operations. 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 simulation software, objects representing physical entities (e.g., cars,

animals) can be cloned from a prototype, allowing for rapid creation of

multiple instances with different states.

Deep Cloning Example:

If you need to perform deep cloning, where not just the properties but also the referenced

objects are cloned, you can adjust the Clone() method to handle the deep copy:

public class GameCharacter : ICloneable

public string Name { get; set; }

public int Health { get; set; }

public List<string> Inventory { get; set; } = new

List<string>();

public ICloneable Clone()

var clone = new GameCharacter

Name = this.Name,

Health = this.Health,

Follow:

Inventory = new List<string>(this.Inventory) // Deep

copy of the Inventory list

return clone;

In this case, the Inventory list will also be cloned to ensure that modifications to the

Inventory of the clone do not affect the original object.

Conclusion:

The Prototype Pattern is a powerful creational pattern that allows you to clone objects

instead of creating them from scratch. It's especially useful when dealing with complex

objects or systems where performance and resource management are important. By using

this pattern, you can quickly create new objects with similar attributes and save time and

resources that would otherwise be spent constructing them from scratch.

Proxy Pattern: Controlling Access to Expensive Resources

Definition:

The Proxy Pattern provides a surrogate or placeholder for another object to control access

to it. The proxy acts as an intermediary, enabling you to perform additional actions (e.g., lazy

loading, access control, logging) before or after delegating operations to the real object.

Use Case:

The Proxy Pattern is useful when you need to control access to an expensive or

resource-intensive object. A common use case is controlling access to resources like large

images, network connections, or database connections. Instead of creating the actual object

immediately, a proxy can delay its creation or manage its lifecycle efficiently.

Code Breakdown:

Answer: In stock trading applications, investors (observers) can subscribe to specific stock prices (subjects) to receive real-time updates whenever the stock price changes.

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 pattern is highly scalable. You can have multiple observers without significantly affecting performance, as the publisher simply iterates through the list of observers. 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 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.