Hans Rohnert

Author

Get more Information

Books

Patterns

Acceptor-Connector

Event Handling Pattern

The Acceptor-Connector design pattern decouples the connection and initialization of cooperating peer services in a networked system from the processing performed by the peer services after they are connected and initialized.

Active Object

Concurrency Pattern

The active object design pattern decouples method execution from method invocation for objects that each live in their own thread of control. The goal is to introduce concurrency, by using asynchronous method invocation and a scheduler for handling requests.

Asynchronous Completion Token

Event Handling Pattern

The Asynchronous Completion Token design pattern allows an application to demultiplex and process efficiently the responses of asynchronous operations it invokes on services.

Blackboard

Architectural Pattern

The Blackboard pattern shows how a complex problem, such as image or speech recognition can be broken up into smaller, specialized subsystems that work together to solve a problem.

Broker

Architectural Pattern

The Broker pattern hides the implementation details of remote service invocation by encapsulating them into a layer other than the business component itself.

Client-Dispatcher-Server

Communication Pattern

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.

Command Processor

Architectural Pattern

Separates the request for a service from its execution. A command processor component manages requests as separate objects, schedules their execution, and provides additional services such as the storing of request objects for later undo.

Component Configurator

Configuration Pattern

The Component Configurator design pattern allows an application to link and unlink its component implementations at run-time without having to modify, recompile, or statically relink the application.

Counted Pointer

Memory Mangement Pattern

The Counted Pointer pattern supports memory management by counting references to dynamically created objects.

Extension Interface

Configuration Pattern

The Extension Interface design pattern allows multiple interfaces to be exported by a component, to prevent bloating of interfaces and breaking of client code when developers extend or modify the functionality of the component.

Forwarder-Receiver

Communication Pattern

The Forwarder-Receiver design pattern provides transparent inter-process communication for software systems with a peer-to-peer interaction model. It introduces forwarders and receivers to decouple peers from the underlying communication mechanism.

Half-Sync/Half-Async

Concurrency Pattern

The Half-Sync/Half-Async architectural pattern decouples asynchronous and synchronous service processing in concurrent systems, to simplify programming without unduly reducing performance. The pattern introduces two intercommunicating layers, one for asynchronous and one for synchronous service processing.

Interceptor

Architectural Pattern

The intercepting filter design pattern is used when we want to do some pre-processing / post-processing with request or response of the application. Filters are defined and applied on the request before passing the request to actual target application.

Layers

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.

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.

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.

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.

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.