Interview Q&A

Answer: s an expression, and the pattern allows for flexible and extensible parsing rules. 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: nimals in an ecosystem), the Flyweight Pattern can be used to share common behaviors or attributes across many instances, reducing memory overhead. 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: ny component and let the pattern take care of the rest. Real-Time Use Case Example:

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.

• By adding new visitors (e.g., another visitor for tax calculation or shipping

fees), you can introduce new operations on the same set of elements without

modifying their classes. This is the key benefit of the Visitor Pattern.

Benefits of the Visitor Pattern:

• The concrete visitor ShoppingCart implements the IShoppingCartVisitor

interface. It performs specific operations on each element, like calculating the total

cost with any applicable discounts. For instance, it applies a 10% discount to books

but no discount to fruits.

public class ShoppingCart : IShoppingCartVisitor
{
private double _total;
public void Visit(Book book) => _total += book.Price * 0.9; //

10% discount on books

public void Visit(Fruit fruit) => _total += fruit.Price; // No

discount on fruits

public double GetTotal() => _total;
}

• The template method ensures that the overall process (e.g., cooking) is

always followed in the same sequence, regardless of the specific recipe. This

prevents inconsistent workflows in different implementations.

When to Use the Template Method Pattern:

Follow:

Answer: When you have multiple classes implementing the same algorithm in slightly different ways, the Strategy Pattern can centralize and avoid code duplication. Drawbacks of the Strategy 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: Each sorting algorithm can be tested independently. Since the algorithms are encapsulated in their own classes, you don't need to test them within the context class. When to Use the Strategy 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: The client (in the Main method) interacts with the Sorter object and can change the strategy at runtime. This makes the system adaptable to different sorting needs without changing the core structure. Benefits of the Strategy 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 state-specific behavior is encapsulated within its corresponding class,

making it easier to add or modify states without affecting the rest of the

system. You can add new states without altering the existing code too much.

When to Use the State Pattern:

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.