What is a pattern?

• Design patterns are recurring solutions to design problems you see over and over [Alpert et al., 98].
• Design patterns constitute a set of rules describing how to accomplish certain tasks in the realm of software development [Pree, 94].
• Design patterns focus more on reuse of recurring architectural design themes, while frameworks focus on detailed design ... and implementation [Coplien et al., 95].
• A pattern addresses a recurring design problem that arises in specific design situations and presents a solution to it [Buschmann et al., 96].
• Patterns identify and specify abstractions that are above the level of single classes and instances, or of components [GoF, 93].
• A pattern is a strategic decision concerning the architecture and implementation of  a software system.

How do you learn patterns?

• Acceptance: accept the premise that this area is important to your work.
• Recognition: recognize that you need to learn in order to use.
• Internalization: internalize enough details to detect needs and apply solutions.

Where do patterns come from?

• Ward Cunningham and Kent Beck paper at OOPSLA'87 on experiment at Tektronix.
• Eric Gamma Ph.D. thesis.
• James Coplien book on C++ Programming Styles and Idioms, Addison-Wesley 1991.
• Peter Coad article on CACM 1992.
• IBM workshop in 1993 with Doug Lea, Kent Beck, Ralph Johnson, John Vlissides, etc.
• Colorado workshop 1993 with Beck, Booch, Cunningham, Johnson, Coplien, etc.
• GoF's Design Patterns: Elements of Reusable Object-Oriented Software, Addison-Wesley 1995.

Studying patterns

• For some lucky people patterns are obvious tools.
• For the rest of us, there is a slow induction process before the proverbial "Aha!".
• Books, courses, sites, and talks are easily available.
• You even have the choice of your favored language.
• Start with classifications and essential elements (metapattern).

Classification

• Creational patterns: create object for you, rather than you having to instantiate object directly.
• Structural patterns: help you compose groups of objects into larger structures, e.g., GUIs.
• Behavioral patterns: help you define the communications between objects and the flow of control.
• More: Fundamental, Partitioning, Concurrency, etc.

Essential Elements

• Name
• Problem
• presents a situation and its context
• lists conditions to be met to apply the pattern
• might describe structures symptomatic of inflexible design
• Solution
• describes elements of the design, their relationships, responsibilities, collaborations
• does not describe code, classes, or concrete design
• might provide abstract design or general arrangement of elements
• Consequences
• evaluates results and trade-offs of the pattern
• compares competitive approaches
• discusses language specific issues
• addresses the impact on the system's flexibility, extensibility, portability

Metapattern tags

• Name
• Classification
• Origin

• Intent (Synopsis)
• Motivation (Context)
• Applicability (Forces)
• Structure (Solution)
• Participants
• Collaborations
• Consequences
• Implementation
• Sample Code
• Known Uses
• Related Patterns

Example Singleton

• Name: Singleton.
• Classification: Creational.
• Origin: GoF 1995.
• Intent: Ensure a class has only one instance, and provide a global point of access to it.
• Motivation: Classes that manage central resources should be unique, e.g., the window manager of a display, the error logger of a compiler, the file system of a computer, the spooler of a printer.
• Applicability: There must be exactly one instance of a class.
• Structure:
• the constructor (must be declared) is private
• a private static variable initialized at class loading time holds the unique instance
• a public static method, getInstance, returns (a reference to) the unique instance
• any other private and public methods as needed
• Participants: only the class itself.
• Collaborations: clients access a singleton through the getInstance method.
• Consequences:
• controlled access to the sole instance
• reduced name space
• permits variable number of instances
• more flexible than class operations
• subclassing is problematic at best
• Implementation:
• must prevent other classes from creating instances
• can create unique instance lazily
• shouldn't be Serializable
• shouldn't be referred to by dynamically loaded classes only
• shouldn't be loaded by a ClassLoader object
• Sample code: e.g., an audio clip manager
 

import java.applet.AudioClip; public class AudioClipManager implements AudioClip {     private static AudioClipManager myInstance = new AudioClipManager ();     private AudioClipManager () {}     public static AudioClipManager getInstance () { return myInstance; }     public void play (AudioClip clip) { ... }     public void loop (AudioClip clip) { ... }     public void stop ()               { ... } }


 
• Known Uses: javax.comm, java.lang.Runtime.
• Related Patterns: factories (e.g., Abstract, Builder, Prototype) are often singletons.

Example Proxy

• Name: Proxy (a.k.a Surrogate).
• Classification: Structural.
• Origin: unknown (Virtual proxy is due to Larman 98).
• Intent: Provide a surrogate or placeholder for another object to control access to it.
• Motivation: Represent with a simpler object an object that is complex or time-consuming to create.
• Applicability:
• Defer the full cost of creating and initializing an object until the object is really needed (virtual proxy).
• Create the illusion that a remote object exists on the local machine (remote proxy).
• Protect access to an object with limited access rights (protection proxy).
• Replace a bare pointer with a smart one, e.g., count references, check locks (smart reference).
• Structure: [a UML diagram would be worth 1K words]
• an interface defines the behavior of a service
• proxy and service (proxee) share the behavior interface
• proxy maintains a reference to the service object
• behavior methods of the proxy generally call the corresponding method of the service
• Participants:
• Interface (also called Subject) defines a service
• Proxy (implements Interface, controls access to Service including its creation)
• Service (also called RealSubject implements Interface, is referenced by Proxy)
• Clients (use Service indirectly through Proxy)
• Collaborations: Proxy forward requests to Service when appropriate, depending on the kind of proxy.
• Consequences:
• a remote proxy can hide the fact that an object resides in a different address space
• a virtual proxy can perform optimizations such as creating an object on demand
• both protection proxy and smart references allow additional housekeeping task when an object is accessed
• a typical proxy optimization is copy-on-write
• Sample code: (no code, only ideas)
• A document editor can embed graphical objects in a document. Loading a large image is expensive and it can be delayed using a proxy until the image becomes visible in the document.
• In a multithreaded application, the enumerator of a collection may need to lock the collection. To prevent locking the collection for a long time, the collection can be cloned, but this may be needlessly expensive. A suitable proxy ensures that the collection is cloned only if a write operation is performed before the enumeration terminates.
• Known Uses: Some Enterprise Java Beans are a form of proxy.
• Related Patterns:
• Adapter provides a different interface to the object it adapts
• Decorator extends the responsibilities of the object it decorates
• Facade uses a single object as front end to a set of related objects

Conclusion

• Patterns are not specifically concerned with algorithms or programming languages.
• Using patterns is fairly independent of development methodologies.
• Cataloging patterns offers a common design vocabulary.
• Knowing patterns makes it easier to understand existing systems.
• Patterns expose an important step between analysis and implementation.
• Patterns reduce the need of refactoring (less prototyping, expanding, consolidating).
• Patterns are strategic decisions in the development of  a software system.