Design Patterns

1994 software engineering book

This article is about the book. For the generic articles, see software design pattern and design pattern.

This article may be in need of reorganization to comply with Wikipedia's layout guidelines. Please help by editing the article to make improvements to the overall structure. (July 2013) (Learn how and when to remove this message)

|

Design Patterns:
Elements of Reusable Object-Oriented Software Object-Oriented+Software&rft.author=

* [[Erich+Gamma]]
* [[Richard+Helm]]
* [[Ralph+Johnson+(computer+scientist)|Ralph+Johnson]]
* [[John+Vlissides]]

&rft.date=1994&rft.pub=[[Addison-Wesley]]&rft.place=United+States&rft.pages=395&rft_id=info:oclcnum/31171684">

Author|

* Erich Gamma
* Richard Helm
* Ralph Johnson
* John Vlissides

Subject| Design patterns, software engineering, object-oriented programming
Publisher| Addison-Wesley

Publication date

| 1994
Publication place| United States
Pages| 395
ISBN| 0-201-63361-2
OCLC| 31171684

Dewey Decimal

| 005.1/2 20
LC Class| QA76.64 .D47 1995

Design Patterns: Elements of Reusable Object-Oriented Software (1994) is a software engineering book describing software design patterns. The book was written by Erich Gamma, Richard Helm, Ralph Johnson, and John Vlissides, with a foreword by Grady Booch. The book is divided into two parts, with the first two chapters exploring the capabilities and pitfalls of object-oriented programming, and the remaining chapters describing 23 classic software design patterns. The book includes examples in C++ and Smalltalk.

It has been influential to the field of software engineering and is regarded as an important source for object-oriented design theory and practice. More than 500,000 copies have been sold in English and in 13 other languages.[1] The authors are often referred to as the Gang of Four (GoF).[2][3][4][5]

## Development and publication history

[edit]

The book started at a birds-of-a-feather session at the 1990 OOPSLA meeting, "Towards an Architecture Handbook", where Erich Gamma and Richard Helm met and discovered their common interest. They were later joined by Ralph Johnson and John Vlissides.[6] The book was originally published on 21 October 1994, with a 1995 copyright, and was made available to the public at the 1994 OOPSLA meeting.

## Introduction

[edit]

This section may contain an excessive amount of intricate detail that may only interest a particular audience. Please help by spinning off or relocating any relevant information, and removing excessive detail that may be against Wikipedia's inclusion policy. (October 2020) (Learn how and when to remove this message)

|

Chapter 1 is a discussion of object-oriented design techniques, based on the authors' experience, which they believe would lead to good object-oriented software design, including:

* "Program to an interface, not an implementation." (Gang of Four 1995:18)
* Composition over inheritance: "Favor 'object composition' over 'class inheritance'." (Gang of Four 1995:20)

The authors claim the following as advantages of interfaces over implementation:

* clients remain unaware of the specific types of objects they use, as long as the object adheres to the interface
* clients remain unaware of the classes that implement these objects; clients only know about the abstract class(es) defining the interface

Use of an interface also leads to dynamic binding and polymorphism, which are central features of object-oriented programming.

The authors refer to inheritance as white-box reuse, with white-box referring to visibility, because the internals of parent classes are often visible to subclasses. In contrast, the authors refer to object composition (in which objects with well-defined interfaces are used dynamically at runtime by objects obtaining references to other objects) as black-box reuse because no internal details of composed objects need be visible in the code using them.

The authors discuss the tension between inheritance and encapsulation at length and state that in their experience, designers overuse inheritance (Gang of Four 1995:20). The danger is stated as follows:

"Because inheritance exposes a subclass to details of its parent's implementation, it's often said that 'inheritance breaks encapsulation'". (Gang of Four 1995:19)

They warn that the implementation of a subclass can become so bound up with the implementation of its parent class that any change in the parent's implementation will force the subclass to change. Furthermore, they claim that a way to avoid this is to inherit only from abstract classes—but then, they point out that there is minimal code reuse.

Using inheritance is recommended mainly when adding to the functionality of existing components, reusing most of the old code and adding relatively small amounts of new code.

To the authors, 'delegation' is an extreme form of object composition that can always be used to replace inheritance. Delegation involves two objects: a 'sender' passes itself to a 'delegate' to let the delegate refer to the sender. Thus the link between two parts of a system are established only at runtime, not at compile-time. The Callback article has more information about delegation.

The authors also discuss so-called parameterized types, which are also known as generics (Ada, Eiffel, Java, C#, Visual Basic (.NET), and Delphi) or templates (C++). These allow any type to be defined without specifying all the other types it uses—the unspecified types are supplied as 'parameters' at the point of use.

The authors admit that delegation and parameterization are very powerful but add a warning:

"Dynamic, highly parameterized software is harder to understand and build than more static software." (Gang of Four 1995:21)

The authors further distinguish between 'Aggregation', where one object 'has' or 'is part of' another object (implying that an aggregate object and its owner have identical lifetimes) and acquaintance, where one object merely 'knows of' another object. Sometimes acquaintance is called 'association' or the 'using' relationship. Acquaintance objects may request operations of each other, but they are not responsible for each other. Acquaintance is a weaker relationship than aggregation and suggests much looser coupling between objects, which can often be desirable for maximum maintainability in designs.

The authors employ the term 'toolkit' where others might today use 'class library', as in C# or Java. In their parlance, toolkits are the object-oriented equivalent of subroutine libraries, whereas a 'framework' is a set of cooperating classes that make up a reusable design for a specific class of software. They state that applications are hard to design, toolkits are harder, and frameworks are the hardest to design.

## Patterns by type

[edit]

### Creational

[edit]

Main article: Creational pattern

Creational patterns are ones that create objects, rather than having to instantiate objects directly. This gives the program more flexibility in deciding which objects need to be created for a given case.

* Abstract factory groups object factories that have a common theme.
* Builder constructs complex objects by separating construction and representation.
* Factory method creates objects without specifying the exact class to create.
* Prototype creates objects by cloning an existing object.
* Singleton restricts object creation for a class to only one instance.

### Structural

[edit]

Structural patterns concern class and object composition. They use inheritance to compose interfaces and define ways to compose objects to obtain new functionality.

* Adapter allows classes with incompatible interfaces to work together by wrapping its own interface around that of an already existing class.
* Bridge decouples an abstraction from its implementation so that the two can vary independently.
* Composite composes zero-or-more similar objects so that they can be manipulated as one object.
* Decorator dynamically adds/overrides behavior in an existing method of an object.
* Facade provides a simplified interface to a large body of code.
* Flyweight reduces the cost of creating and manipulating a large number of similar objects.
* Proxy provides a placeholder for another object to control access, reduce cost, and reduce complexity.

### Behavioral

[edit]

Most behavioral design patterns are specifically concerned with communication between objects.

* Chain of responsibility delegates commands to a chain of processing objects.
* Command creates objects that encapsulate actions and parameters.
* Interpreter implements a specialized language.
* Iterator accesses the elements of an object sequentially without exposing its underlying representation.
* Mediator allows loose coupling between classes by being the only class that has detailed knowledge of their methods.
* Memento provides the ability to restore an object to its previous state (undo).
* Observer is a publish/subscribe pattern, which allows a number of observer objects to see an event.
* State allows an object to alter its behavior when its internal state changes.
* Strategy allows one of a family of algorithms to be selected on-the-fly at runtime.
* Template method defines the skeleton of an algorithm as an abstract class, allowing its subclasses to provide concrete behavior.
* Visitor separates an algorithm from an object structure by moving the hierarchy of methods into one object.

## Reception

[edit]

In 2005 the ACM SIGPLAN awarded that year's Programming Languages Achievement Award to the authors, in recognition of the impact of their work "on programming practice and programming language design".[7]

Criticism has been directed at the concept of software design patterns generally, and at Design Patterns specifically. A primary criticism of Design Patterns is that its patterns are simply workarounds for missing features in C++, replacing elegant abstract features with lengthy concrete patterns, essentially becoming a "human compiler". Paul Graham wrote:[8]

> When I see patterns in my programs, I consider it a sign of trouble. The shape of a program should reflect only the problem it needs to solve. Any other regularity in the code is a sign, to me at least, that I'm using abstractions that aren't powerful enough-- often that I'm generating by hand the expansions of some macro that I need to write.

Peter Norvig demonstrates that 16 out of the 23 patterns in Design Patterns are simplified or eliminated by language features in Lisp or Dylan.[9] Related observations were made by Hannemann and Kiczales who implemented several of the 23 design patterns using an aspect-oriented programming language (AspectJ) and showed that code-level dependencies were removed from the implementations of 17 of the 23 design patterns and that aspect-oriented programming could simplify the implementations of design patterns.[10]

In an interview with InformIT in 2009, Erich Gamma stated that the book authors had a discussion in 2005 on how they would have refactored the book and concluded that they would have recategorized some patterns and added a few additional ones, such as extension object/interface, dependency injection, type object, and null object. Gamma wanted to remove the singleton pattern, but there was no consensus among the authors to do so.[11]

## See also

[edit]

* Software design pattern
* Enterprise Integration Patterns
* GRASP (object-oriented design)
* Pedagogical patterns

## References

[edit]

1. ^ Zehoo, Edmund (26 January 2010). Zehoo, Edmund (ed.). Pro ODP .NET for Oracle Database 11g. Apress. pp. 351–371\. doi:10.1007/978-1-4302-2821-9_13 - via Springer Link.
2. ^ Hussain, Shahid; Keung, Jacky; Khan, Arif Ali (2017). "The Effect of Gang-of-Four Design Patterns Usage on Design Quality Attributes". 2017 IEEE International Conference on Software Quality, Reliability and Security (QRS). pp. 263–273\. doi:10.1109/QRS.2017.37. ISBN 978-1-5386-0592-9. S2CID 21343926.
3. ^ Hunt, John (26 January 2013). Hunt, John (ed.). Scala Design Patterns: Patterns for Practical Reuse and Design. Springer International Publishing. pp. 135–136\. doi:10.1007/978-3-319-02192-8_16 - via Springer Link.
4. ^ Almadi, Sara H. S.; Hooshyar, Danial; Ahmad, Rodina Binti (26 January 2021). "Bad Smells of Gang of Four Design Patterns: A Decade Systematic Literature Review". Sustainability. 13 (18): 10256. doi:10.3390/su131810256.
5. ^ Monteiro, Miguel Pessoa; Fernandes, João M. (26 January 2004). Pitfalls of aspectJ implementations of some of the gang-of-four design patterns. Universidad de Extremadura. ISBN 978-84-688-8889-7 - via repositorium.uminho.pt.
6. ^ Richard Helm
7. ^ "SIGPLAN FY '05 Annual Report" (PDF).
8. ^ Graham, Paul (2002). Revenge of the Nerds. Retrieved 11 August 2012.
9. ^ Norvig, Peter (1998). Design Patterns in Dynamic Languages.
10. ^ Hannemann, Jan (2002). Design pattern implementation in Java and AspectJ.
11. ^ Gamma, Erich; Helm, Richard; Johnson, Ralph (22 October 2009). "Design Patterns 15 Years Later: An Interview with Erich Gamma, Richard Helm, and Ralph Johnson". InformIT (Interview). Interviewed by Larry O'Brien. Archived from the original on 20 February 2019. Retrieved 1 September 2019.

* v
* t
* e

Software design patterns

Gang of Four
patterns|

| Creational|

* Abstract factory
* Builder
* Factory method
* Prototype
* Singleton

|

Structural|

* Adapter
* Bridge
* Composite
* Decorator
* Facade
* Flyweight
* Proxy

Behavioral|

* Chain of responsibility
* Command
* Interpreter
* Iterator
* Mediator
* Memento
* Observer
* State
* Strategy
* Template method
* Visitor

Concurrency
patterns|

* Active object
* Balking
* Binding properties
* Double-checked locking
* Event-based asynchronous
* Guarded suspension
* Join
* Lock
* Monitor
* Proactor
* Reactor
* Read–write lock
* Scheduler
* Scheduled-task pattern
* Semaphore
* Thread pool
* Thread-local storage

Architectural
patterns|

* Front controller
* Interceptor
* MVC
* MVP
* MVVM
* ADR
* ECS
* n-tier
* Specification
* Publish–subscribe
* Naked objects
* Service locator
* Active record
* Identity map
* Data access object
* Data transfer object
* Inversion of control
* Model 2
* Broker

Other
patterns|

* Blackboard
* Business delegate
* Composite entity
* Dependency injection
* Guard clause
* Intercepting filter
* Lazy loading
* Mock object
* Null object
* Object pool
* Servant
* Twin
* Type tunnel
* Method chaining
* Delegation

Books|

* Design Patterns
* Enterprise Integration Patterns

People|

* Christopher Alexander
* Erich Gamma
* Ralph Johnson
* John Vlissides
* Grady Booch
* Kent Beck
* Ward Cunningham
* Martin Fowler
* Robert Martin
* Jim Coplien
* Douglas Schmidt
* Linda Rising

Communities|

* The Hillside Group
* Portland Pattern Repository

See also|

* Anti-pattern
* Architectural pattern

*[OCLC]: Online Computer Library Center number
*[LC Class]: Library of Congress Classification
*[v]: View this template
*[t]: Discuss this template
*[e]: Edit this template