s8

Question 1

What is a pattern?

Answer 1

A recurring theme, design, or arrangement observable in various contexts; a regularity in data, behavior, structures, or events.

Question 2

What is a Design Pattern in software?

Answer 2

A general, reusable solution to a commonly occurring software design problem. It’s a template to be modified and implemented, not ready-made code.

Question 3

What are Design Patterns concerned with?

Answer 3

Application & System Design.
Abstractions on top of code.
Relationships between classes & other collaborators.
Problems that have already been solved.

Question 4

What are Design Patterns NOT concerned with?

Answer 4

Algorithms.
Specific implementations or classes.

Question 5

How do Design Patterns differ from Architectural Styles?

Answer 5

Architectural Styles: Focus on components and their relationships (higher-level diagrams like component, activity diagrams).

Design Patterns: Focus on low-level code, objects, and classes (expect code, class diagrams). (Note: The line between them can be blurry).

Question 6

Why are Design Patterns useful?

Answer 6

Help anticipate and manage change in software.
Can target complex conditional logic.
Provide a common language for developers to communicate solutions.

Question 7

What is an Anti-Pattern?

Answer 7

A design pattern that is ineffective and counterproductive, representing common pitfalls in software design.

Question 8

Name some common Anti-Patterns and briefly describe them.

Answer 8

Spaghetti Code (Big Ball of Mud): Ad hoc software structure, difficult to extend and optimize.

Lava Flow: Unready code put into production and added to while still unfinished.

Golden Hammer: Obsessively applying a familiar tool to every software problem.

Boat Anchor: Code that doesn’t do anything is left in the codebase “just in case.”

God Class: One class taking on too many responsibilities.

Poltergeist Class: Useless classes with no real responsibility, often just invoking methods in another class or adding unneeded abstraction.

Question 9

What are the SOLID Principles and who introduced them?

Answer 9

A set of guidelines for writing high-quality, maintainable, and scalable software, introduced by Robert C. Martin. They help developers write software that is easy to understand, modify, and extend.

Question 10

What does SOLID stand for?

Answer 10

Single Responsibility Principle (SRP)
Open-Closed Principle (OCP)
Liskov Substitution Principle (LSP)
Interface Segregation Principle (ISP)
Dependency Inversion Principle (DIP)

Question 11

Explain the Single Responsibility Principle (SRP).

Answer 11

A class should have only one reason to change, meaning it should have only one responsibility or job. Too many responsibilities lead to code that is difficult to understand and maintain.

Question 12

Explain the Open-Closed Principle (OCP).

Answer 12

Software entities (classes, modules, functions) should be open for extension but closed for modification. Behavior can be extended without modifying existing source code, promoting extensibility and maintainability.

Question 13

Explain the Liskov Substitution Principle (LSP).

Answer 13

Any instance of a derived class should be substitutable for an instance of its base class without affecting the program’s correctness. A derived class should behave like its base class in all contexts.

Question 14

Explain the Interface Segregation Principle (ISP).

Answer 14

No client should be forced to depend on methods it does not use. It’s better to create smaller, more focused interfaces for specific use cases rather than large, general-purpose interfaces. This results in more cohesive and less coupled interfaces.

Question 15

Explain the Dependency Inversion Principle (DIP).

Answer 15

High-level modules should not depend on low-level modules; both should depend on abstractions. Abstractions should not depend on details; details should depend on abstractions. This aims to reduce coupling and increase modularity.

Question 16

Name the main categories of Design Patterns

Answer 16

Creational: Deal with object creation mechanisms.

Structural: Deal with organizing objects into larger structures and providing new functionality.

Behavioral: Deal with common communication patterns between objects.

Concurrency: Deal with multi-threaded programs.

Question 17

What is the main goal of Creational Design Patterns?

Answer 17

To abstract object creation, allowing flexibility (polymorphism), decoupling clients from concrete classes, and managing how objects are created. They often shift emphasis from pure inheritance to composition and interfaces.

Question 18

What is the Prototype Pattern?

Answer 18

Creates instances of an object by cloning a prototypical instance. Cloning existing objects can be computationally cheaper and copies encapsulated attributes that the client might not know.

Question 19

What are the main components of the Prototype Pattern?

Answer 19

Prototype: Defines the interface for cloned objects (e.g., a clone() method).
ConcretePrototype: Implements the Prototype interface to perform cloning.
Client: Creates an initial instance of a ConcretePrototype and then clones it to make additional instances.

Question 20

When should you use the Prototype Pattern?

Answer 20

When a system should be independent of how its products are created, composed, and represented.

When the class to be instantiated is selected at run-time.

When instances of a class have few different combinations of state (cloning pre-configured prototypes is easier).

Question 21

List pros of the Prototype Pattern.

Answer 21

Clone objects without coupling to their concrete classes.

Reduce repeated initialization code by cloning pre-built prototypes.

Produce complex objects more conveniently.

Alternative to inheritance for configuration presets of complex object

Question 22

List cons of the Prototype Pattern.

Answer 22

Cloning complex objects with circular references can be very tricky.

Question 23

What is the Factory Method Pattern (or Simple Factory concept)?

Answer 23

Suggests replacing direct object construction calls (new operator) with calls to a special factory method. The new operator is still used, but within the factory method. Objects returned are often called “products.”

Question 24

What are the main components of the Factory Method Pattern?

Answer 24

Product: Defines the interface for objects the factory method create
s.
ConcreteProduct: Implements the Product interface.

Creator (or Factory): Declares the factory method, which returns an object of type Product. May also define a default implementation.

ConcreteCreator (or ConcreteFactory): Overrides the factory method to return an instance of a ConcreteProduct.

Question 25

When should you use the Factory Method Pattern?

Answer 25

When a class can't anticipate the class of objects it must create. When a class wants its subclasses to specify the objects it creates. When you want to localize knowledge about object creation.

Question 26

List pros of the Factory Method Pattern.

Answer 26

Modular expandability (Open-Closed Principle). Delegates object creation (Single Responsibility Principle). Straightforward to test.

Question 27

List cons of the Factory Method Pattern.

Answer 27

Requires more classes than a straightforward constructor call.

Question 28

What is the Abstract Factory Pattern (Kit Pattern)?

Answer 28

Provides an interface for creating families of related or dependent objects without specifying their concrete classes. Factories can be implemented using factory methods or prototypes.

Question 29

What are the main components of the Abstract Factory Pattern?

Answer 29

AbstractProduct: Interface for a type of product. ConcreteProduct: Implements an AbstractProduct interface. AbstractFactory: Declares an interface for operations that create abstract product objects. ConcreteFactory: Implements the operations to create concrete product objects.   Client: Uses interfaces declared by AbstractFactory and AbstractProduct.

Question 30

When should you use the Abstract Factory Pattern?

Answer 30

When a system should be independent of how its products are created, composed, and represented. When a system should be configured with one of multiple families of products. When a family of related product objects is designed to be used together, and this constraint needs to be enforced. When providing a class library of products, revealing only interfaces, not implementations.

Question 31

List pros of the Abstract Factory Pattern.

Answer 31

Ensures products from a factory are compatible. Avoids tight coupling between concrete products and client code. Product creation code is centralized (SRP). Can introduce new variants of products without breaking client code (OCP).

Question 32

List cons of the Abstract Factory Pattern.

Answer 32

Code can become more complicated due to many new interfaces and classes.

Question 33

What is the Builder Pattern?

Answer 33

Separates the construction of a complex object from its representation, allowing the same construction process to create different representations.  

Question 34

What is the motivation for using the Builder Pattern?

Answer 34

To avoid a large number of subclasses for different configurations or a very messy constructor with many parameters when creating complex objects. It breaks object construction into steps.

Question 35

What are the main components of the Builder Pattern?

Answer 35

Product: The complex object to be built. Builder: Interface for creating parts of the Product. ConcreteBuilder: Implements the Builder interface to construct and assemble parts of the product. Director (Optional): Coordinates the Builder to construct the object in a specific sequence.

Question 36

When should you use the Builder Pattern?

Answer 36

When the algorithm for creating a complex object should be independent of the parts that make it up and how they're assembled. When the construction process must allow different representations for the object being constructed (e.g., stone house vs. wooden house).

Question 37

List pros of the Builder Pattern.

Answer 37

Construct objects step-by-step, defer steps, or run steps recursively. Reuse the same construction code for various product representations. Isolate complex construction code from business logic (SRP).

Question 38

List cons of the Builder Pattern.

Answer 38

Overall code complexity increases due to creating multiple new classes.

Question 39

What is the Singleton Pattern?

Answer 39

Restricts the instantiation of a class to a single instance and provides a global point of access to it.

Question 40

How is the Singleton Pattern typically implemented?

Answer 40

The default constructor is made private. A static creation method is used, which calls the private constructor only the first time it's invoked and returns the same instance on subsequent calls

Question 41

How do Singletons differ from Global Variables?

Answer 41

Both are globally accessible, but Singletons can encapsulate/hide information, avoid cluttering namespaces, allow for lazy allocation (memory allocated only when needed), and can be subclassed.

Question 42

When should you use the Singleton Pattern?

Answer 42

When there must be exactly one instance of a class, and it must be accessible to clients from a well-known access point. (Often considered an anti-pattern by some).

Question 43

List pros of the Singleton Pattern.

Answer 43

Ensures only a single instance of a class. Provides a global access point to that instance. The object is initialized only when first requested (lazy initialization).

Question 44

List cons of the Singleton Pattern.

Answer 44

Can mask bad design (components know too much about each other). Can lead to tighter coupling. Hard to execute correctly in multi-threaded environments. Hard to create mock singletons for testing. Not future-proof if more than one instance is needed later. Violates Single Responsibility Principle (manages its own lifecycle in addition to its primary role).

Question 45

Name some other Creational Patterns not in the original GoF list.

Answer 45

Dependency Injection: An object receives objects it depends on. Lazy Initialization: Object creation is delayed until actually needed. Multiton: Generalizes Singleton to multiple instances. Object Pool: Recycles objects from a pool instead of creating/destroying them.

Question 46

What are some pitfalls of using Design Patterns?

Answer 46

Don't design for patterns; refactor initial designs to patterns if appropriate. Optimization is often secondary to getting a product out. Uncritical use can turn them into anti-patterns. Some patterns might be unnecessary due to language features. Approach to patterns can change with different languages/paradigms.