Software Design and Architectural Patterns

Interface segregation 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.

Leaky Abstraction

Anti Pattern

An abstraction that exposes details and limitations of its underlying implementation to its users that should ideally be hidden away.

Liskov substitution 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.

Model-View-Controller (MVC)

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.

Model-View-Update (MVU)

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.

Model-View-ViewModel (MVVM)

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.

Monitor Object

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.

Null Object

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.

Open closed principle


Software entities ... should be open for extension, but closed for modification.

Pimpl Idiom

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.

Pipes and Filters

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.