Interview Q&A

Answer: When a log message is passed to the infoLogger, it checks if it can handle the message. If the message level is Info, it processes the message. If not, it passes the request to the next handler (errorLogger).

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 the builder, you can add more ingredients or properties in a fluent manner (i.e., chaining method calls), which can make the code cleaner and more readable.

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: You can easily add new shapes or drawing styles without changing existing classes. This is particularly useful in scenarios where the number of shapes or rendering methods can grow over time.

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: New platforms can be added by creating new concrete factories. The client code doesn’t need to change; just use the new factory.

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 separates the algorithm (e.g., calculating total with discounts) from the objects on which it operates. This makes the object structure (elements) cleaner, as they are not responsible for the business logic.

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: in an object structure. The visitor pattern is particularly useful when operations are performed on different types of objects, and each type requires specific behavior. Drawbacks of 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.

Answer: llow for customization in certain steps. For example, when implementing generic frameworks for various kinds of workflows, like validation, report generation, or business processes. Drawbacks of the Template Method 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: bstract class. Additionally, the order and structure of steps remain consistent cross different subclasses.

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.

nd overriding the abstract steps. Benefits of the Template Method 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.

lgorithms, the Strategy Pattern can help simplify and modularize your code.

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.

nd you need to manage the transitions between states in a clean, maintainable way. It's

ideal for situations like traffic lights, game characters, or process workflows, where the object

changes its behavior dynamically. By encapsulating the behavior of each state in separate

classes, you can avoid complex conditionals and promote better code organization and

flexibility.

Strategy Pattern: Encapsulating Algorithms for Interchangeability

Definition:

The Strategy Pattern defines a family of algorithms, encapsulates each one, and makes

them interchangeable. This pattern allows an algorithm to vary independently from clients

that use it. It is particularly useful when you want to choose between different algorithms

dynamically at runtime, without altering the code that uses them.

Use Case:

typical use case for the Strategy Pattern is sorting. Instead of implementing multiple

sorting algorithms directly in the client code, you can use the strategy pattern to choose

which sorting algorithm to apply (e.g., QuickSort, BubbleSort, MergeSort) depending on the

context or runtime conditions.

Code Breakdown:

Answer: nd maintain since objects can rely on the Singleton without explicitly passing it.

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: ctions. The TextEditor focuses only on managing and modifying the content, nd the Memento class simply holds the state. This separation of concerns makes the system more modular and easier to maintain.

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.

lso create a dependency on the mediator itself. Over-reliance on the

mediator can lead to issues if the mediator needs to change.

Visual Diagram:

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

| IChatMediator |

| (Mediator Interface) |

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

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

| |

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

| ChatMediator | | User |

| (Concrete Mediator) | (Colleague) |

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

| |

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

| RegisterUser(User)| | Send(string) |

| SendMessage(...) | | Receive(string) |

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

Conclusion:

The Mediator Pattern is an excellent solution for managing complex interactions between

objects in a system, particularly when those objects don’t need to know about each other

directly. It reduces dependencies, simplifies communication, and centralizes control, making

it easier to manage interactions. However, it should be used judiciously, as a poorly

implemented mediator can become a bottleneck or a single point of failure in the system.

Memento Pattern: Real-Time Example - Undo Feature in a Text Editor

Definition:

The Memento Pattern is used to capture and externalize an object's internal state without

violating encapsulation. This allows the object to be restored to this state later. It’s commonly

used in situations where an object's state changes over time and you may need to revert to

previous states, such as an undo feature.

Use Case:

The Memento Pattern is widely used in scenarios where you want to implement an undo or

restore functionality, such as in a text editor. In this case, the pattern allows the editor to

save versions of the text and restore them when the user requests an undo.

Code Breakdown:

Answer: nd labels. For example, clicking a button might update a text field, and the mediator ensures that these updates are propagated correctly.

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.

nd the interpreter evaluates these statements to execute the program.

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.

complex character (e.g., with styling information) could consist of several

flyweight components (like the base character, font style, size, etc.).

Visual Diagram:

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

| CharacterFactory |

| (Flyweight Factory) |

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

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

| |

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

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

| Character | | Character

| <--- Flyweight Objects

| (Intrinsic State)| | (Intrinsic

State)|

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

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

| |

| * Shared across all objects |

+--------------------------------------------------->+

(Position, Size, Text displayed are external/unique)

(Memory saved by sharing the intrinsic state)

Conclusion:

The Flyweight Pattern provides a powerful way to manage large numbers of similar objects

efficiently by sharing common state and minimizing memory usage. It’s particularly beneficial

in scenarios like text rendering, game graphics, or large-scale simulations where creating

numerous identical objects would be costly in terms of memory and performance. By

pplying this pattern, you can significantly reduce the memory footprint and improve the

performance of your application while maintaining flexibility in managing the objects' unique

properties.

Interpreter Pattern: Real-Time Example - Parsing and Evaluating

Mathematical Expressions

Definition:

The Interpreter Pattern defines a representation for a grammar along with an interpreter to

interpret sentences in that grammar. It is used to evaluate expressions or interpret complex

languages by breaking them down into simpler components that can be recursively

evaluated.

Use Case:

typical use case for the Interpreter Pattern is parsing and evaluating mathematical

expressions, like addition, subtraction, multiplication, or division. It allows for flexible and

dynamic evaluation of complex expressions.

Code Explanation:

Answer: nd ConsoleLogger. These classes define how the log message will be handled, either by writing to a file or outputting to the console.

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.

re logged (either to a file or the console).

FileLogger:

public class FileLogger : ILogger
{
public void Log(string message) => Console.WriteLine($"Logging

to file: {message}");

}

ConsoleLogger:

public class ConsoleLogger : ILogger
{
public void Log(string message) => Console.WriteLine($"Logging

to console: {message}");

}

Answer: re abstracted into a simplified process, allowing users to perform transactions without understanding the underlying complexities.

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.

ltering or subclassing the core class.

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.

bout whether the child is a file or a subdirectory.

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: nd calls its Undo() method, which reverts the action performed by the command (removes the last added text). Key Benefits of the Command 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.

• If a handler can't process a message, it passes the request along to the next

handler in the chain (i.e., by calling NextLogger?.LogMessage(...)).

This continues until a handler processes the message or the chain is

exhausted.

Key Benefits of the Chain of Responsibility Pattern:

dapted to the same target interface. Each adapter can map different

methods and behaviors from the adaptees.

• Adapter Chaining:
• Sometimes, you may need to chain multiple adapters to work with more

complex systems. Each adapter could transform data in a specific way to fit

the final target.

• Type Safety:
• If you are working in a strongly-typed language (like C#), make sure that your

dapter respects type constraints and offers clear type mappings between the

daptee and the target.

Real-Time Use Case Example:

The Adapter Pattern is often used when integrating third-party libraries into existing

pplications. For example:

• Integrating a payment gateway API into an e-commerce system that expects a

specific interface.

• Wrapping legacy systems or older versions of a library that are not compatible with

your new system architecture.

• Adapting external APIs to match internal interfaces in microservices architectures.

Visual Diagram:

Here’s a simple illustration of how the Adapter Pattern works: