Software Design and Architectural Patterns

Leader/Followers

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.

Manager

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.

Mediator

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.

Memento

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.

Microkernel

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

Observer

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.

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.

Presentation-Abstraction-Control

Architectural Pattern

The PAC architectural pattern defines a structure for interactive software systems in the form of a hierarchy of cooperating agents. Every agent is responsible for a specific aspect of the application's functionality and consists of three components: presentation, abstraction, and control.

Proactor

Event Handling Pattern

The Proactor architecture pattern demultiplexes and dispatches service requests that are triggered by the completion of asynchronous operations.

Product Trader

Creational Pattern

Lets clients create objects by naming an abstract superclass and by providing a specification. A Product Trader decouples the client from the product and thereby eases the adaptation, configuration and evolution of class hierarchies, frameworks and applications.

Prototype

Creational Pattern

The prototype pattern is used to instantiate a new object by copying all of the properties of an existing object, creating an independent clone. This practise is particularly useful when the construction of a new object is inefficient.

Proxy

Structural Pattern

The proxy pattern is used to provide a surrogate or placeholder object, which references an underlying object. The proxy provides the same public interface as the underlying subject class, adding a level of indirection by accepting requests from a client object and passing these to the real subject object as necessary.

Publish/Subscribe (pub/sub)

Architectural Pattern

Publish/Subscribe is a messaging pattern where a publisher sends messages to a channel without the knowledge of who is going to receive them. It is the responsibility of the channel to deliver a copy of the messages to each subscriber.

Reactor

Event Handling Pattern

The Reactor design pattern handles service requests that are delivered concurrently to an application by one or more clients.

Reflection

Architectural Pattern

The Reflection architectural pattern provides a mechanism for changing structure and behavior of software systems dynamically. It supports the modification of fundamental aspects, such as type structures and function call mechanisms. In this pattern, an application is split into two parts. A meta level provides information about selected system properties and makes the software self-aware. A base level includes the application logic. Its implementation builds on the meta level. Changes to information kept in the meta level affect subsequent base-level behavior.