What are Patterns?
The following contains a tentative definition of what we are looking for in
the pilot study and what we should record when we find it.
Table of Contents
What is a design pattern?
- Solution to a problem in a context
- Consequently, we should be able to determine what problem is being solved
- We should be able to say what sort of (non-functional) constraints (the
- We should look for language independent patterns
- We should look for patterns that are independent of the application area
of the program being considered
- We should be able to identify the relevant area of the source code
- The patterns should extend beyond a single function
- We should determine what if any state the pattern manages
- We should attempt to distinguish the pattern's genotype from its phenotype
- We should attempt to determine the degrees of freedom/extent of generality
of the pattern
- We should try to give the pattern a name
A Pattern Template
The following is a design-pattern template in the the Gang of
Four style. We may want to consider using it to documenting what we find.
- Pattern Name (Scope, Purpose)
The pattern's name conveys the essence of the pattern succinctly. A
good name is vital, because it will become part of your design
A short statement that answers the following questions: What does the
design pattern do? What is its rationale and intent? What particular
design issue or problem does it address?
- Also Known As
Other well-known names for the pattern, if any.
A scenario that illustrates a design problem and how the class and
object structures in the pattern solve the problem. The scenario will
help you understand the more abstract description of the pattern that
What are the situations in which the design pattern can be applied?
What are examples of poor designs that the pattern can address? How can
you recognize these situations?
The classes and/or objects participating in the design pattern and
How the participants collaborate to carry out their responsibilities.
How does the pattern support its objectives? What are the trade-offs
and results of using the pattern? What aspect of system structure does
it let you vary independently?
What pitfalls, hints, or techniques should you be aware of when
implementing the pattern? Are there language-specific issues?
- Sample Code and Usage
Code fragments that illustrate how you might implement the pattern in
C++ or Smalltalk.
- Known Uses
Examples of the pattern found in real systems. We include at least two
examples from different domains.
- Related Patterns
What design patterns are closely related to this one? What are the
important differences? With which other patterns should this one be
This page last modified on 11 November 1997.