Principle
Many client-specific interfaces are better than one general-purpose interface
Behavioral Pattern
The interpreter pattern is used to define the grammar for instructions that form part of a language or notation, whilst allowing the grammar to be easily extended.
Behavioral Pattern
An iterator provides the interface to traverse a container's elements. The implementation is hidden so that the client does not need to understand the traversing algorithm.
Architectural Pattern
The Layered architectural pattern helps to structure applications that can be decomposed into groups of subtasks in which each group of subtasks Is at a particular level of abstraction.
Concurrency Pattern
The Leader/Followers architectural pattern that provides an efficient concurrency model where multiple threads take turns sharing a set of event sources in order to detect, demultiplex, dispatch, and process service requests that occur on the event sources.
Anti Pattern
An abstraction that exposes details and limitations of its underlying implementation to its users that should ideally be hidden away.
Principle
Objects in a program should be replaceable with instances of their subtypes without altering the correctness of that program.
Behavioral Pattern
The Manager design pattern encapsulates management of a class’ objects into a separate manager object. This allows variation of management functionality independent of the class and the manager’s reuse for different classes.
Behavioral Pattern
The mediator pattern is used to reduce coupling between classes that communicate with each other. Instead of classes communicating directly, and thus requiring knowledge of their implementation, the classes send messages via a mediator object.
Behavioral Pattern
The memento pattern is used to capture the current state of an object and store it in such a manner that it can be restored at a later time without breaking the rules of encapsulation.
Architectural Pattern
The Microkernel architectural pattern applies to software systems that must be able to adapt to changing system requirements. It separates a minimal functional core from extended functionality and customer-specific parts. The microkernel also serves as a socket for plugging in these extensions and coordinating their collaboration.
Architectural Pattern
The MVC pattern separates the domain models (model), the presentation (view), and the actions based on external input (controller) into three separate classes.
Architectural Pattern
You have a Model, send it to the View to render, and the View calls update methods, that update the Model back to the Model to update.
Architectural Pattern
The MVVM pattern separates the presentation logic (view) from its abstract representation (view model). The view model provides access to the model data and operations which operate on models.
Concurrency Pattern
The Monitor Object design pattern synchronizes concurrent method execution to ensure that only one method at a time runs within an object. It also allows an object's methods to cooperatively schedule their execution sequences.
Behavioral Pattern
Instead of using a null reference to convey absence of an object (for instance, a non-existent customer), one uses an object which implements the expected interface, but whose method body is empty. The advantage of this approach over a working default implementation is that a Null Object is very predictable and has no side effects: it does nothing.
Behavioral Pattern
The observer pattern is used to allow an object to publish changes to its state. Other objects subscribe to be immediately notified of any changes.
Principle
Software entities ... should be open for extension, but closed for modification.
Structural Pattern
The PIMPL Idiom (Pointer to IMPLementation) is a technique for implementation hiding in which a public class wraps a structure or class that cannot be seen outside the library the public class is part of.
Architectural Pattern
The Pipes and Filters architectural pattern provides a structure for systems that process a stream of data. Each processing step is encapsulated in a filter component. Data [are] passed through pipes between adjacent filters. Recombining filters allows you to build families of related filters.