When is it appropriate to consider using the Facade Pattern?
When dealing with a small, well-defined set of classes.
When you need to simplify the interface to a complex subsystem.
When you want to expose the internal implementation details of a system.
When the interaction with a subsystem is already simple and straightforward.
How does the Command Pattern achieve decoupling?
By using inheritance to create specialized request handlers.
By directly connecting the object making the request with the object fulfilling it.
By relying on a central registry to map requests to their handlers.
By introducing an intermediary object (the Command) between the invoker and the receiver.
When might the Strategy Pattern introduce unnecessary complexity?
When performance is absolutely critical, and the overhead of strategy objects is a concern.
When the algorithms are very similar and could be easily combined into a single class.
When you have a small number of algorithms that are unlikely to change.
When the context needs to be aware of the concrete strategy being used.
Which of the following is NOT a typical category of design patterns?
Behavioral
Structural
Functional
Creational
What is a potential downside of overusing design patterns?
Reduced code complexity
Increased code readability
Improved code performance
Unnecessary complexity and abstraction
In a scenario where you are designing a game with different enemy types, how might the Factory Method pattern be applied?
Create a single factory class responsible for instantiating all enemy types based on given parameters.
Use a dependency injection framework to inject concrete enemy instances into the game logic.
Hardcode the instantiation of each enemy type directly within the game logic where needed.
Define an abstract 'EnemyFactory' with a 'createEnemy' method, and have subclasses for each enemy type implement their creation logic.
Which type of design pattern deals with object creation mechanisms?
Architectural
In Python, a common way to implement a Singleton is by using:
Interfaces
Decorators
Multiple inheritance
Abstract classes
What is a key consideration when implementing the Singleton pattern in a multi-threaded application?
Avoiding any form of synchronization to improve performance.
Ensuring that only one instance can be created, even under concurrent access.
Creating separate instances for each thread.
Using global variables to store the Singleton instance.
Which of these is NOT a core component of the Strategy Pattern?
Context
ConcreteStrategy
Factory
Strategy