Pattern-Oriented Sofware Archicture--A System of Patterns

By: F. Buschmann, R. Meunier, H. Rohnert, P. Sommerlad, M. Stal
Published in: Wiley, 1996

Summary: A collection of patterns that spans several levels of abstraction but concentrates on software architecture.

Pattern: Layers

Structure an application to be decomposed into groups of subtasks where each group is at a given level of abstraction.

Category: Architectural, Networks

• Microkernel is a specialized layered architecture.
• Presentation-Abstraction-Control also emphasizes levels of increasing abstraction, but the overall structure is a tree of nodes rather than a vertical line of nodes layered on top of each other.
• A Hierarchy of Control Layers, Four-Layer Architecture, Layered Architecture [Shaw95], Layered Organization, Layered and Sectioned Architecture, Pedestal, Shape of Program, Three-Tier Architecture

Pattern: Pipes & Filters

For systems that process a stream of data. Each processing step is encapsulated in a filter component. Data passes through pipes that connect filters. Combining filters produces families of related systems.

• Layers is better for systems that require reliable operation, since it is easier to implement error handling. However, Layers does not support the easy recombination and reuse of components, the key feature of this pattern.

Pattern: Blackboard

For problems with no deterministic solutions, use several specialized subsystems to assemble knowledge to build a partial solution.

Category: Architectural

Pattern: Broker

Produce distributed software systems with decoupled components that interact by remote service invocations. The broker coordinates communication, e.g., forwards requests, transmits results and exceptions.

Category: Architectural, Distributed Systems

Pattern: Model-View-Controller

Divide an interactive application into three components. The model contains the core functionality and data. Views display information to the user. Controllers handle user input. Views and controllers together comprise the user interface. A change-propagation mechanism ensures consistency between the user interface and the model.

Category: Architectural

• In Presentation-Abstraction-Control, the abstraction component corresponds to the model in Model-View-Controller (MVC), and the view and controller are combined into a presentation component. Communication between abstraction and presentation components is decoupled by the control component. The interaction between presentation and abstraction is not limited to calling an update procedure, as it is in MVC.
• Session Control & Observation is a specialization of MVC that controls and maintains the state of a networked multimedia session and notifies those interested in that state.

Pattern: Presentation-Abstraction-Control

Define a hierarchy of cooperating agents to structure interactive software systems. Each agent is responsible for an aspect of the application's functionality and consists of three components: presentation, abstraction, and control. These components separate human-computer aspects of the agent from its functional core and its communication with other agents.

Category: Architectural

• Model-View-Controller also separates the functional core of a system from information display and user input handling.

Pattern: Microkernel

For software systems that must adapt to changing system requirements, separate a minimal functional core from extended functionality and customer-specific parts. The microkernel is a socket for plugging in these extensions and coordinating their collaboration.

Category: Architectural

• Broker is applicable for distributed systems comprising interacting, decoupled components. Clients access services using remote procedure calls or message passing. Broker focuses on distribution across a network. The coupling of components with Broker is not as tight as in this pattern. Broker and Microkernel could be used in a distributed system.
• Reflection provides a two-tiered architecture. The base level corresponds to a combination of this pattern and internal servers.

Pattern: Reflection

Split the application into two parts: (1) a meta level provides information about selected system properties and makes the software self-aware; (2) a base level builds on the meta level and includes the application logic. Changes to the meta level affect base level behavior. This allows the system to dynamically change structure and behavior.

Category: Architectural

• Microkernel supports adaptation and change by allowing additional functionality. The microkernel is a socket for plugging in extensions and coordinating their collaboration.
• Prototype-Based Object System takes this pattern to its logical conclusion.

Pattern: Whole-Part

An aggregate component (the whole) encapsulates constituent components (the parts), organizes their collaboration, and provides a common interface to the functionality. Direct access to the parts is not allowed.

Category: Structural

• As a variant of this pattern, Composite [Gamma+95] is applicable for representing whole-part hierarchies of objects when clients should ignore differences between compositions of objects and individual objects. Clients will treat all objects in the composite structure uniformly.
• Facade [Gamma+95] provides a simple interface to a complex subsystem. Clients use this interface instead of accessing subsystem components directly; however, Facade [Gamma+95] does not force encapsulation of the components. Clients can still access them directly.

Pattern: Master-Slave

Handle computation of replicated services in a system to achieve fault tolerance and robustness. Separate independent slave components that together provide the same service to a master component, which is responsible for invoking them and for selecting a result. Clients communicate only with the master.

Category: Architectural

Pattern: Proxy

Contains: Proxy [Gamma+95],

Pattern: Command Processor

Separates the request for a service from its execution, manages requests as separate objects, schedules their execution, and provides additional services, e.g., storing request objects for a later undo.

• This pattern extends Command [Gamma+95]

Pattern: View Handler

Manage all views of a software system and allow clients to open, manipulate, and dispose of views. Coordinate dependencies between views and organize updates.

Category: GUI Development

• Model-View-Controller provides an infrastructure for separating functionality from input and output behavior. This pattern is a refinement of the relationship between the model and its associated views.
• Presentation-Abstraction-Control (PAC) implements the coordination of multiple views following this pattern. An intermediate level PAC agent that creates and coordinates views, corresponds to View Handler. Lower-level PAC agents that present data to the user are view components.

Pattern: Forwarder-Receiver

Provide transparent interprocess communication for software systems with a peer-to-peer interaction model. Forwarders and receivers decouple peers from the underlying communication mechanisms.

Category: Communications, Distributed Systems

• Client-Dispatcher-Server provides transparent interprocess communication when the distribution of components is not known at compile-time or may vary at run-time.

Pattern: Client-Dispatcher-Server

A dispatcher component is an intermediary between clients and servers. The dispatcher provides location transparency with a name service and hides details of the communication connection.

Category: Client-Server, Communications, Distributed Systems

• Forwarder-Receiver can be combined with this pattern to hide details of interprocess communication.
• Acceptor and Connector decouple connection set-up from connection processing.

Pattern: Publisher-Subscriber

Keep the state of cooperating components synchronized by enabling one-way propagation of changes. One publisher notifies any number of subscribers about changes to its state.

Category: Behavioral

• The publisher is the subject in Observer [Gamma+95]. The subscribers are observers.

Pattern: Counted Pointer

Improves memory management of dynamically allocated, shared objects in C++ by introducing a reference counter to a body class updated by handle objects. Clients access body class objects only through handles. This pattern was first described in [Coplien92] and later expanded in [Coplien99c]

Category: C++ Idioms