CSC/ECE 517 Fall 2009/wiki2 12 Schemes for Pattern Classification

Overview

Design patterns in software engineering is a time-tested reusable solution to recurring problems in software design. The origin of design patterns can be owed to the work of civil engineer Christopher Alexander, who documented his resolution to design issues in constructing buildings and towns[1]. About a decade and a half ago, software professional began to incorporate Alexanders ideas into guides for novice developer. From then on design patterns became increasingly popular.

Schemes for Pattern Classification

Gang of Four's Classification

Design Patterns gained popularity with the book Design Patterns: Elements of Reusable Object-Oriented Software by Erich Gamma, Richard Helm, Ralph Johnson and John Vlissides published in 1995. In their work they used 2 criteria to categorize 23 design pattern[2].

• What does the pattern do?
  • Structural - These patterns deal with the composition of classes and their object.
  • Creational - These patterns deal with object creation.
  • Behavioral - These patterns deal with the interaction between classes and object and how they delegate responsibility.

• What is the scope of the pattern?
  • Class - The patterns deal with the relationships between classes and their subclasses. These are more static and fixed at compile time.
  • Object - These patterns deal with object relationship. They are more dynamic and can vary at runtime.

Example of Design Patterns that fall into each Category

Purpose
Scope	Creational	Structural	Behavioral
Class	Factory Method	Adapter (class)	Interpreter
			Template Method
Object	Abstract Factory	Adapter (object)	Command
	Prototype	Composite	Mediator
	Builder	Bridge	Iterator
	Singleton	Decorator	Memento
		Facade	Observer
		Flyweight	State
		Proxy	Strategy
			Visitor
			Chain Of Responsibility

Zimmer's Classification

Zimmer[3] classifies the relationships between the Gang of Four design patterns. Focusing on the problem and solution of each relationship, they can be classified as :

• X uses Y in its solution.
  • The Interpreter design pattern uses the Composite design patter.
  • The Prototype design pattern uses the Singleton design pattern.
• Variant of X uses Y in its solution.
  • Some variant of the Bridge design pattern may uses the Adapter design pattern.
• X is similar to Y.
  • The Mediator design pattern is similar to the Facade design pattern.

Using these relationships Zimmer placed design pattern in 3 layers.

Layer	Design Pattern
Basic design patterns and techniques.	Singleton, Template Method, Mediator, Facade, Memento, Iterator, Flyweight.
Design patterns for typical software problems.	Abstract Factory, Builder, Strategy, Observer, Bridge, Adapter, Prototype, Factory Method, State, Command, Visitor, Composite, Decorator, Chain Of Responsibility, Proxy
Design patterns specific to an application domain.	Interpreter

Coad's Classification

In 1992 Peter Coad published his first article of design patterns. According to Coad, design patterns are identified observing classes, objects and the relationships established between them[5]. In his book Object Models: Strategies, Patterns, and Applications, Peter Coad along with David North and Mark Mayfield organized patterns into various pattern families[4].

• Fundamental Pattern: This pattern is the template that all the other patterns follow.
  • Collection-Worker Pattern is the fundamental object model pattern.
• Transaction Patterns: These either have transaction players or have players that commonly play with the transaction player. The transaction patterns are:
  • Actor-Participant pattern.
  • Participant-Transaction pattern.
  • Place-Transaction pattern.
  • Specific Item-Transaction pattern.
  • Transaction-Transaction Line Item pattern.
  • Transaction-Subsequent Transaction pattern.
  • Transaction Line Item-Subsequent Transaction Line Item pattern.
  • Item-Line Item pattern.
  • Specific Item-Line Item.
  • Item-Specific Item.
  • Associate-Other Associate.
  • Specific Item-Hierarchical Item.
• Aggregate Patterns: These patterns interconnect with other patterns. The aggregate patterns are:
  • Container-Content pattern.
  • Container-Container Line Item pattern.
  • Group-Member.
  • Assembly-Part pattern.
  • Compound Part-Part pattern.
  • Packet-Packet Component.
• Plan Patterns: The plan patterns are:
  • Plan-Step pattern.
  • Plan-Plan Execution pattern.
  • Plan Execution-Step Execution pattern.
  • Step-Step Execution pattern.
  • Plan-Plan Version pattern.
• Interaction Patterns: These patterns, as the name suggests are patterns of interaction. The interaction patterns are:
  • Peer-Peer pattern.
  • Proxy-Specific Item pattern.
  • Publisher-Subscriber pattern.
  • Sender-Pass Through-Receiver pattern.
  • Sender-Lookup-Receiver pattern.
  • Caller-Dispatcher-Caller Back pattern.
  • Gatekeeper-Request-Resource pattern.

Pree's Classification

In his book Design Patterns for Object-Oriented Software Development, Addison-Wesley, 1995, Wolfgang Pree categorized Coad's patterns into[5]:

• Basic inheritance and interaction patterns: These patterns encompass primarily the basic modelling capabilities offered by object oriented programming languages.
• Patterns for structuring object-oriented software systems: Most of Coad's patterns belong to this category.
• Patterns related to the MVC framework: Those of Coad's patterns that stress the framework aspect are derivatives of the Model/View/Controller framework.

Ignoring the fine-grained[5] pattern classification proposed by Gamma's catalog, Pree applied the following classification of the listed patterns.

• Patterns relying on abstract coupling.
• Patterns based on recursive structures.
• Other Catalog patterns.

Tichy's Classification

Walter Tichy classified several design patterns based on the kind of problems they solved. He grouped the problems into the following high-level categories[6]:

• Decoupling: dividing a software system into in-dependent parts in such a way that the parts can be built, changed, replaced, and reused independently. Decoupling patterns can be further classified into:
  • Modules(Encapsulation/Information Hiding)[7]: The purpose of this design pattern is to hide data structure and operations that are most likely to change, thus protecting other parts of the system from the effects of those changes. Examples for support of modules are
    • Modula's modules.
    • C's header files.
    • Ada's packages.
  • Abstract Data Type[ADT]: Some examples of ADT

• Variant Management: treating different objects uniformly by factoring out their commonality.
• State Handling: generic manipulation of object state.
• Control: control of execution and method selec-tion.
• Virtual Machines: simulated processors.
• Convenience Patterns: simplified coding.
• Compound Patterns: patterns composed from others, with the original patterns visible.
• Concurrency: controlling parallel and concurrent execution.
• Distribution: problems germane to distributed systems.

References

[1] http://www.developer.com/design/article.php/1474561/What-Are-Design-Patterns-and-Do-I-Need-Them.htm
[2] http://www.cs.umu.se/~jubo/ExJobbs/MK/patterns.htm
[3] Relationships between Design Patterns, by Walter Zimmer, Forschungszentrum Informatik, Bereich Programmstrukturen, 1995
[4] Peter Coad, with David North, and Mark Mayfield. Object Models: Strategies, Patterns, and Applications. Englewood Cliffs, NJ: Prentice Hall, 1995.
[5] Wolfgang Pree. Design Patterns for Object-Oriented Software Development. Addison-Wesley, 1995.
[6] Tichy, Walter F (1998), A Catalogue of General-Purpose Software Design Patterns. University of Karlsruhe, Karlsruhe, Germany.
[7] Parnas, D. L. 1972. On the criteria to be used in decomposing systems into modules. Commun. ACM 15, 12 (Dec. 1972), 1053-1058.
[8] Some Patterns for Software Architectures, Mary Shaw, Carnegie Mellon University