Interview Q&A

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:

• Even though the pattern allows you to add new operations without modifying

the element classes, you still need to ensure that visitors and elements are

compatible. This can lead to some level of coupling between visitors and

element classes.

Conclusion:

The Visitor Pattern is an excellent choice when you need to separate the operations

performed on a structure from the structure itself, particularly in cases where the structure is

complex and may evolve over time. It allows you to introduce new operations without

modifying existing object classes. However, it can become difficult to manage when you

need to add new element types, as every visitor must be updated to handle the new type.

This pattern is often used in scenarios like processing different kinds of products in a

shopping cart, applying various types of discounts or taxes, or performing different

transformations on elements of a composite structure.

Answer: Operations are centralized in the visitor, which makes it easier to manage complex operations. If multiple operations are performed on the same structure, they can be handled by different visitors.

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 concrete visitor implements the visitor interface and defines the specific logic for each element. In this case, the ShoppingCart visitor calculates the total price, applying discounts where necessary.

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 concrete element classes Book and Fruit implement the

IShoppingCartElement interface. Each class has a price and the Accept

method that allows the visitor to perform an operation on it.

public class Book : IShoppingCartElement
{
public double Price { get; }
public Book(double price) => Price = price;
public void Accept(IShoppingCartVisitor visitor) =>

visitor.Visit(this);

}
public class Fruit : IShoppingCartElement
{
public double Price { get; }
public Fruit(double price) => Price = price;
public void Accept(IShoppingCartVisitor visitor) =>

visitor.Visit(this);

}

• When you want to reuse common behavior across different subclasses, but

allow 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:

• The pattern allows for reusing the general flow of the algorithm (the steps in

the Cook method) while customizing certain steps in different subclasses.

This makes it easy to add new recipes by simply extending the Recipe class

and overriding the abstract steps.

Benefits of the Template Method Pattern:

Answer: If you find yourself writing long if/else or switch statements to select algorithms, 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.

Answer: The Sorter class is the context. It doesn't perform the sorting itself but delegates it to whatever strategy is currently set. The client can change the strategy dynamically, making the system flexible and extensible.

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 Sorter class acts as the context that uses the strategy. It has a method

SetStrategy that allows clients to set the desired sorting strategy dynamically. The

Sort method delegates the sorting task to the currently set strategy.

public class Sorter
{
private ISortStrategy _strategy;
public void SetStrategy(ISortStrategy strategy) => _strategy =

strategy;

public void Sort(List<int> list) => _strategy.Sort(list);
}

• Since state transitions happen within different classes, it may be harder to

track down state-related bugs, especially in more complex systems.

Conclusion:

The State Pattern is an excellent choice when an object's behavior is contingent on its state,

and 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

Follow:

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:

A 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: The pattern eliminates the need for complex conditional logic (e.g., if or switch statements) in the context class. Each state class defines its own behavior, and the context class only delegates the work.

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 TrafficLight class holds the current state and delegates behavior to the state object. The context can change its state by calling the SetState method, which updates the current state reference.

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: It can lead to hidden dependencies, making the code harder to understand and 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: As shown in the example, lazy initialization is used to create the instance only when needed, with thread safety ensured by locking.

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: For managing global caching mechanisms, where there’s a single shared cache used by the entire application.

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.