Design Patterns

Design Pattern - the thing
Design Patterns - the book
Software Design Pattern

Patterns Catalogue
Patterns Links

Do Factory - .NET
OO Design
Wiki Books
Workflow Patterns
Java Design Pattern Stories
Source Making

Creational Design Patterns

Abstract Factory

Creates an instance of several families of classes


Separates object construction from its representation

Factory Method

Creates an instance of several derived classes

Object Pool

Avoid expensive acquisition and release of resources by recycling objects that are no longer in use


A fully initialized instance to be copied or cloned


A class of which only a single instance can exist

Structural Design Patterns


Match interfaces of different classes


Separates an object’s interface from its implementation


A tree structure of simple and composite objects


Add responsibilities to objects dynamically


A single class that represents an entire subsystem


A fine-grained instance used for efficient sharing

Private Class Data

Restricts accessor/mutator access


An object representing another object

Behavioral Design Patterns

Chain of responsibility

A way of passing a request between a chain of objects


Encapsulate a command request as an object


A way to include language elements in a program


Sequentially access the elements of a collection


Defines simplified communication between classes


Capture and restore an object's internal state

Null Object

Designed to act as a default value of an object


A way of notifying change to a number of classes


Alter an object's behavior when its state changes


Encapsulates an algorithm inside a class

Template Method

Defer the exact steps of an algorithm to a subclass


Defines a new operation to a class without change

Convention Over Configuration

Convention over configuration (also known as coding by convention) is a software design paradigm which seeks to decrease the number of decisions that developers need to make, gaining simplicity, but not necessarily losing flexibility.

Intent ... Design a framework so that it enforces standard naming conventions for mapping classes to resources or events. A programmer only needs to write the mapping configurations when the naming convention fails ...

As the designer of a framework, use the Convention over Configuration pattern when

there are clear and practical naming conventions that can be established between parts of the framework.

there is the opportunity to reduce the amount of configuration files that duplicate mapping information from other parts of the system.

The Convention over Configuration pattern does not preclude the need for configuration files. Configuration files are still important for the cases where convention fails. But for most cases, sticking to the conventions works and keeps things simple for the programmer and anyone reading the code.

See Ruby#RubyOnRails

Search wiki for 'convention'

Architectural Design Pattern

An architectural pattern is a general, reusable solution to a commonly occurring problem in software architecture within a given context. Architectural patterns are similar to software design patterns but have a broader scope ...

An architectural pattern is a concept that solves and delineates some essential cohesive elements of a software architecture. Countless different architectures may implement the same pattern and share the related characteristics. Patterns are often defined as "strictly described and commonly available".

For example, the layered architecture is a call-and-return style because it defines an overall style to interact. When it is strictly described and commonly available, it is a pattern.


Also See




Search wiki for 'pattern'

Last modified 3 years ago Last modified on 04/17/2015 04:20:05 PM