OO Patterns

Douglas C. Schmidt

Patterns and Frameworks

Introduction to Patterns and Frameworks

Motivation for Patterns and Frameworks

Douglas C. Schmidt
Professor [email protected] www.cs.wustl.edu/schmidt/ Department of EECS Vanderbilt University (615) 343-8197

What is a Pattern? A Framework? Pattern Categories Pattern Examples

Vanderbilt University

OO Patterns

Douglas C. Schmidt

OO Patterns

Douglas C. Schmidt

Motivation for Patterns and Frameworks

,: * * 56 4-

Overview of Patterns and Frameworks

Patterns support reuse of software architecture and design Patterns capture the static and dynamic structures and collaborations of successful solutions to problems that arise when building applications in a particular domain Frameworks support reuse of detailed design and code A framework is an integrated set of components that collaborate to provide a reusable architecture for a family of related applications Together, design patterns and frameworks help to improve software quality and reduce development time e.g., reuse, extensibility, modularity, performance
2 Vanderbilt University 3

Developing software is hard

)6 )
,1)/ 561+56)61 5

Developing reusable software is even harder Proven solutions include patterns and frameworks www.cs.wustl.edu/schmidt/ patterns.html

)6 )
)6 )

+ 756-4 * * 56 4-

,) 161-5 +6  4 +4

+- 64) *56 4-

Vanderbilt University

OO Patterns

Douglas C. Schmidt

OO Patterns

Douglas C. Schmidt

Patterns of Learning
Successful solutions to many areas of human endeavor are deeply rooted in patterns In fact, an important goal of education is transmitting patterns of learning from generation to generation In a moment, well explore how patterns are used to learn chess Learning to develop good software is similar to learning to play good chess Though the consequences of failure are often far less dramatic!

Becoming a Chess Master

First learn the rules
e.g., names of pieces, legal movements, chess board geometry and orientation, etc.

Then learn the principles

e.g., relative value of certain pieces, strategic value of center squares, power of a threat, etc.

However, to become a master of chess, one must study the games of other masters
These games contain patterns that must be understood, memorized, and applied repeatedly

There are hundreds of these patterns

Vanderbilt University 4 Vanderbilt University 5

OO Patterns

Douglas C. Schmidt

OO Patterns

Douglas C. Schmidt

Becoming a Software Design Master

First learn the rules
e.g., the algorithms, data structures and languages of software

Design Patterns
Design patterns represent solutions to problems that arise when developing software within a particular context i.e., Pattern == problem/solution pair in a context Patterns capture the static and dynamic structure and collaboration among key participants in software designs They are particularly useful for articulating how and why to resolve non-functional forces Patterns facilitate reuse of successful software architectures and designs

Then learn the principles

e.g., structured programming, modular programming, object oriented programming, generic programming, etc.

However, to become a master of software design, one must study the designs of other masters
These designs contain patterns that must be understood, memorized, and applied repeatedly

There are hundreds of these patterns

Vanderbilt University 6 Vanderbilt University 7

OO Patterns

Douglas C. Schmidt

OO Patterns

Douglas C. Schmidt

Example: Stock Quote Service

57* -+6 ,4-) 61 )4 -6 ,)6).--,

Structure of the Observer Pattern

B HA=?D E  >IAHLAHI  KF@=JA A @ F F

Key Forces 1. There may be many observers 2. Each observer may react differently to the same notication

Intent
>IAHLAH KF@=JA

5K> A?J JEBO =JJ=?D >IAHLAH @AJ=?D >IAHLAH

 >IAHLAHI

1 1+)6 )22 - ,- 6 2 1 ,1 1+)6 6 )22 ,,-2-

56 + 37 6-5

3. The subject should be as decoupled as possible from the observers

+ ?HAJA 5K> A?J CAJ IJ=JA IK> A?J IJ=JA

IK> A?J

+ ?HAJA >IAHLAH KF@=JA

IK> A?J CAJ IJ=JA

Dene a one-to-many dependency between objects so that when one object changes state, all its dependents are notied and updated automatically.

*5-48-45

i.e., allow observers to change independently of the subject

8

HAJKH IK> A?J IJ=JA

Vanderbilt University

Vanderbilt University

OO Patterns

Douglas C. Schmidt

OO Patterns

Douglas C. Schmidt

Graphical Notation
24 +-55 604-),
+ ?HAJA 5K> A?J

Collaboration in the Observer Pattern

+ ?HAJA >IAHLAH + ?HAJA Variations >IAHLAH

IAJ IJ=JA JEBO

Push architectures combine control ow and data ow Pull architectures separate control ow from data ow

* -+6 + )55

6- 2 )6+ )55

KF@=JA CAJ IJ=JA KF@=JA CAJ IJ=JA

1 0-4165

6)1

- 6

Vanderbilt University

10

Vanderbilt University

11

OO Patterns

Douglas C. Schmidt

OO Patterns

Douglas C. Schmidt

Design Pattern Descriptions

Main parts 1. Name and intent 2. Problem and context 3. Force(s) addressed 4. Abstract description of structure and collaborations in solution 5. Positive and negative consequence(s) of use 6. Implementation guidelines and sample code 7. Known uses and related patterns
Vanderbilt University 12 Vanderbilt University

Frameworks
1. Frameworks are semi-complete applications Complete applications are developed by inheriting from, and instantiating parameterized framework components 2. Frameworks provide domain-specic functionality

Pattern descriptions are often independent of programming language or implementation details Contrast with frameworks

e.g., business applications, telecommunication applications, window systems, databases, distributed applications, OS kernels
3. Frameworks exhibit inversion of control at run-time

i.e., the framework determines which objects and methods to invoke in response to events

13

OO Patterns
)22 1+)61 52-+1.1+ .7 +61 ) 16;
+) 1 8 +)61 5

Douglas C. Schmidt

OO Patterns

Douglas C. Schmidt

Class Libraries vs. Frameworks vs. Patterns

)60 + )55-5

Component Integration in Frameworks

)22 1+)61 + ,-

Denition

),6
+ )55-5 ,)6)*)5+ )55-5

Class libraries
Self-contained, pluggable ADTs

Framework components are loosely coupled via callbacks Callbacks allow independently developed software components to be connected together Callbacks provide a connection-point where generic framework objects can communicate with application objects The framework provides the common template methods and the application provides the variant hook methods

-8- 6 2

/ 7+ ,-

/71
+ )55-5

-69 4

12+

+ )55-5

)+

)55 1*4)4;)4+016-+674-69 4 1 /
-8- 6 2

Frameworks
Reusable, semi-complete applications

-8- 6 0) , -45

?= >=? 
,152)6+0-4 -8- 6 2

),6
+ )55-5

)22 1+)61
1 8 )60 + )55-5 -5

/71
+) *)+ 5 -8- 6 2

Patterns
Problem, solution, context

52-+1.1+ .7 +61 ) 16;

-8- 65- 5 4 5;56+ ,-

,)6)*)5-

-8- 6 2

*.4)

-9 4 )4+016-+674-

Vanderbilt University

14

Vanderbilt University

15

OO Patterns

Douglas C. Schmidt

OO Patterns

Douglas C. Schmidt

Comparing Patterns and Frameworks

Reactor/Proactor I/O Strategy Framework State Singleton Cached Virtual Filesystem

Design Pattern Space

Creational patterns
Deal with initializing and conguring classes and objects

Patterns and frameworks are highly synergistic

~
/home/...
Strategy

Protocol Handler Protocol Filter Adapter

Active Object

In general, sophisticated frameworks embody dozens of patterns and patterns are often used to document frameworks
Vanderbilt University 16 Vanderbilt University 17

OO Patterns

Factory Method
Method in a derived class creates associates

Abstract Factory
Factory for building related objects

Builder
Factory for building complex objects incrementally

Prototype
Factory for cloning new instances from a prototype

Singleton
Factory for a singular (sole) instance
Vanderbilt University 18

Strategy

Asynchronous Completion Token

Tilde Expander

i.e., neither is subordinate Patterns can be characterized as more abstract descriptions of frameworks, which are implemented in a particular language

Event Dispatcher

Structural patterns
Deal with decoupling interface and implementation of classes and objects

Acceptor

Protocol Pipeline Framework Streams

Concurrency Strategy Framework Service Configurator

Behavioral patterns
Deal with dynamic interactions among societies of classes and objects

Douglas C. Schmidt

OO Patterns

Douglas C. Schmidt

Creational Patterns
Adapter

Structural Patterns

Translator adapts a server interface for a client

Bridge
Abstraction for binding one of many implementations

Composite
Structure for building recursive aggregations

Decorator
Decorator extends an object transparently

Vanderbilt University

19

OO Patterns

Douglas C. Schmidt

OO Patterns

Douglas C. Schmidt

Structural Patterns (contd)

Facade
Facade simplies the interface for a subsystem

Behavioral Patterns
Chain of Responsibility
Request delegated to the responsible service provider

Flyweight
Many ne-grained objects shared efciently

Command
Request as rst-class object

Proxy
One object approximates another

Interpreter
Language interpreter for a small grammar

Iterator
Aggregate elements are accessed sequentially

Vanderbilt University

20

Vanderbilt University

21

OO Patterns

Douglas C. Schmidt

OO Patterns

Douglas C. Schmidt

Behavioral Patterns (contd)

Mediator
Mediator coordinates interactions between its associates

Behavioral Patterns (contd)

Strategy
Abstraction for selecting one of many algorithms

Memento
Snapshot captures and restores object states privately

Template Method
Algorithm with some steps supplied by a derived class

Observer
Dependents update automatically when a subject changes

Visitor
Operations applied to elements of an heterogeneous object structure

State
Object whose behavior depends on its state

Vanderbilt University

22

Vanderbilt University

23

OO Patterns

Douglas C. Schmidt

OO Patterns

Douglas C. Schmidt

When to Use Patterns

1. Solutions to problems that recur with variations No need for reuse if the problem only arises in one context 2. Solutions that require several steps Not all problems need all steps Patterns can be overkill if solution is simple linear set of instructions 3. Solutions where the solver is more interested in the existence of the solution than its complete derivation Patterns leave out too much to be useful to someone who really wants to understand They can be a temporary bridge, however
Vanderbilt University 24

What Makes a Pattern a Pattern?

A pattern must: Solve a problem, i.e., it must be useful!

Teach
It must provide sufcient understanding to tailor the solution

Have a context,
It must describe where the solution can be used

Have a name
It must be referred to consistently

Recur,
It must be relevant in other situations

Vanderbilt University

25

Do

572-4 815 4

  +- 6-4 ) )/-4

OO framework for Call Center Management

System Overview

572-4 815 4

OS platforms are often fundamentally incompatible e.g., different concurrency and I/O models Thus, it may be impractical to directly reuse:

572-4 815 4

-69 4

Vanderbilt University

26

Vanderbilt University

Algorithms Detailed designs Interfaces Implementations

OO Patterns

572-4 815 4

-8- 6 5-48-4

5916+0 0) , -45

+)

Developing portable, reusable, and efcient communication software is hard

,

6- -+ 5916+0-5

www.cs.wustl.edu/schmidt/PDF/ECOOP95.pdf

-41+55

,

-41+55

4A=?J H

Case Study: A Reusable Object-Oriented Communication Software Framework

www.cs.wustl.edu/schmidt/PDF/DSEJ-94.pdf

OO Patterns

Douglas C. Schmidt

572-4815 4 0) , -45

OO Patterns

Douglas C. Schmidt

OO Patterns

Douglas C. Schmidt

Problem: Cross-platform Reuse

Protocol Handlers (HTTP)

Solution: Reuse Design Patterns

2K> EIDAH 5K>I?HE>AH =OAHI )??AFJ H + A?J H
564)6-/1+ 2)66-4 5 6)+61+) 2)66-4 5 1JAH=J H

OO framework was rst developed on UNIX and later ported to Windows NT 3.51 in 1993 UNIX and Windows NT have fundamentally different I/O models i.e., synchronous vs. asynchronous Thus, direct reuse of original framework was infeasible Later solved by ACE and Windows NT 4.0

Patterns support reuse of software architecture

2EFAI .E JAHI + F A J + BECKH=J H

WaitForCompletion()

I/O Subsystem

I/O Completion Port

Patterns embody successful solutions to problems that arise when developing software in a particular context Patterns reduced project risk by leveraging proven design expertise

read() write() read() write() read() read() accept()

4A=?J H
+ HO F IEJA .=?J AJD @
2H NO 9H=FFAH .=?=@A

Vanderbilt University

28

Vanderbilt University

29

OO Patterns

Douglas C. Schmidt

OO Patterns

Douglas C. Schmidt

The Reactor Pattern

4A=?J H D= @ A ALA JI HACEIJAH D= @ AHD HA LA D= @ AHD
KIAI IA A?JD= @ AI B HA=?DDE D= @ AI F J=> A D D= @ A ALA JJOFA A @ F

Collaboration in the Reactor Pattern

=E FH CH= ?= >=?  4A=?J H + ?HAJA -LA J 0= @ AH 4A=?J H HACEIJAH D= @ AH?= >=?  CAJ D= @ A D= @ A ALA JI IA A?J D= @ A E FKJ D= @ A KJFKJ

Intent

D= @ AHI  M I

1 161) 1 )61 ,-

0= @ A
JEBEAI

-LA J0= @ AH D= @ A ALA JJOFA CAJ D= @ A + ?HAJA -LA J 0= @ AH

Decouples synchronous event demuxing & dispatching from event handling

Forces Resolved Efciently demux events synchronously within one thread Extending applications without changing demux infrastructure

Note inversion of control Also note how long-running event handler callbacks can degrade quality of service

1 161) 1 4-/156-40) , -4 -:64)+60) , 56)46-8- 6 2

-8- 60) , 1 / ,-

5O ?DH KI-LA J ,A K JEF ANAH IA A?J

. 4-)+0-8- 6, ,)6))4418-5 6 5- , 51/ ) )4418-5 61 -4-:214-5 48-0) , -4

www.cs.wustl.edu/schmidt/POSA/

D= @ A IEC =  D= @ A JE A KJ HA LA D= @ AH?= >=?  D= @ A ? IA

+ -) 72

Vanderbilt University

30

Vanderbilt University

31

Do

OO Patterns

Douglas C. Schmidt

Using ACEs Reactor Pattern Implementation

#include "ace/Reactor.h" class My_Event_Handler : public ACE_Event_Handler { public: virtual int handle_input (ACE_HANDLE h) { cout << "input on handle " << h << endl; return 0; } virtual int handle_signal (int signum, siginfo_t *, ucontext_t *) { cout << "signal " << signum << endl; return 0; } virtual ACE_HANDLE get_handle (void) const { return ACE_STDIN; } };
Vanderbilt University 32

int main (int argc, char *argv[]) { My_Event_Handler eh; ACE_Reactor reactor;

reactor.register_handler (&eh, ACE_Event_Handler::READ_MASK);

Using ACEs Reactor Pattern Implementation (contd)

for (;;) reactor.handle_events ();

reactor.register_handler (SIGINT, &eh);

/* NOTREACHED */ return 0;

OO Patterns

Douglas C. Schmidt

OO Patterns

Douglas C. Schmidt

Differences Between UNIX and Windows NT

Reactive vs. Proactive I/O
Reactive I/O is synchronous Proactive I/O is asynchronous  Requires additional interfaces to arm the I/O mechanism See Proactor pattern  www.cs.wustl.edu/schmidt/POSA/ Other differences include Resource limitations  e.g., Windows WaitForMultipleObjects() limits HANDLEs per-thread to 64 Demultiplexing fairness  e.g., WaitForMultipleObjects always returns the lowest active HANDLE
Vanderbilt University 34

Lessons Learned from Case Study

Real-world constraints of OS platforms can preclude direct reuse of communication software e.g., must often use non-portable features for performance Reuse of design patterns may be the only viable means to leverage previous development expertise Design patterns are useful, but are no panacea Managing expectations is crucial Deep knowledge of platforms, systems, and protocols is also very important

Vanderbilt University

35

Vanderbilt University

OO Patterns

OO Patterns

Douglas C. Schmidt

OO Patterns

Douglas C. Schmidt

Key Principles
Successful patterns and frameworks can be boiled down to a few key principles: 1. Separate interface from implementation 2. Determine what is common and what is variable with an interface and an implementation Common == stable 3. Allow substitution of variable implementations via a common interface Dividing commonality from variability should be goal-oriented rather than exhaustive

Planning for Change

Often, aspects of a design seem constant until they are examined in the light of the dependency structure of an application At this point, it becomes necessary to refactor the framework or pattern to account for the variation Frameworks often represent the distinction between commonality and variability via template methods and hook methods, respectively

Vanderbilt University

36

Vanderbilt University

37

OO Patterns

Douglas C. Schmidt

OO Patterns

Douglas C. Schmidt

The Open/Closed Principle

Determining common vs. variable components is important Insufcient variation makes it hard for users to customize framework components Conversely, insufcient commonality makes it hard for users to comprehend and depend upon the frameworks behavior In general, dependency should always be in the direction of stability i.e., a software component should not depend on any component that is less stable than itself The Open/Closed principle This principle allows the most stable component to be extensible

The Open/Closed Principle (contd)

Components should be: open for extension closed for modication Impacts Abstraction is good Inheritance and polymorphism are good Public data members and global data are bad Run-time type identication can be bad

Vanderbilt University

38

Vanderbilt University

39

OO Patterns

Douglas C. Schmidt

OO Patterns

Douglas C. Schmidt

Violation of Open/Closed Principle

struct Shape { enum Type { CIRCLE, SQUARE } shape_type; /* . . . */ }; void draw_square (const Square &); void draw_circle (const Circle &); void draw_shape (const Shape &shape) { switch (shape.shape_type) { case SQUARE: draw_square ((const Square &) shape); break; case CIRCLE: draw_circle ((const Circle &) shape); break; // etc.

Application of Open/Closed Principle

class Shape { public: virtual void draw () const = 0; }; class Square : public Shape { /* . . . */ }; class Circle : public Shape { /* . . . */ }; typedef vector<Shape> Shape_Vector; void draw_all (const Shape_Vector &shapes) { for (Shape_Vector::iterator i = shapes.begin(); i != shapes.end (); i++) (*iterator).draw (); }
40 Vanderbilt University 41

Vanderbilt University

OO Patterns

Douglas C. Schmidt

OO Patterns

Douglas C. Schmidt

Benets of Design Patterns

Design patterns enable large-scale reuse of software architectures
They also help document systems to enhance understanding

Drawbacks to Design Patterns

Patterns do not lead to direct code reuse Patterns are deceptively simple Teams may suffer from pattern overload Patterns are validated by experience and discussion rather than by automated testing Integrating patterns into a software development process is a human-intensive activity

Patterns explicitly capture expert knowledge and design tradeoffs, and make this expertise more widely available Patterns help improve developer communication
Pattern names form a vocabulary

Patterns help ease the transition to object-oriented technology

Vanderbilt University

42

Vanderbilt University

43

OO Patterns

Douglas C. Schmidt

OO Patterns

Douglas C. Schmidt

Tips for Using Patterns Effectively

Do not recast everything as a pattern.
Instead, develop strategic domain patterns and reuse existing tactical patterns

Lessons Learned using OO Frameworks

Benets of frameworks
Enable direct reuse of code Facilitate larger amounts of reuse than stand-alone functions or individual classes

Institutionalize rewards for developing patterns Directly involve pattern authors with application developers and domain experts Clearly document when patterns apply and do not apply Manage expectations carefully

Drawbacks of frameworks
High initial learning curve  Many classes, many levels of abstraction The ow of control for reactive dispatching is non-intuitive Verication and validation of generic components is hard

Vanderbilt University

44

Vanderbilt University

45

OO Patterns

Douglas C. Schmidt

OO Patterns

Douglas C. Schmidt

Patterns and Framework Literature

Books Gamma et al., Design Patterns: Elements of Reusable Object-Oriented Software AW, 94 Pattern Languages of Program Design series by AW, 95-99. Siemens & Schmidt, Pattern-Oriented Software Architecture, Wiley, volumes 96 & 00 (www.posa.uci.edu) Schmidt & Huston, C++ Network Programming: Mastering Complexity with ACE and Patterns, AW, 02 (www.cs.wustl.edu/schmidt/ACE/book1/) Schmidt & Huston, C++ Network Programming: Systematic Reuse with ACE and Frameworks, AW, 03 (www.cs.wustl.edu/schmidt/ACE/book2/)

Conferences and Workshops on Patterns

Pattern Language of Programs Conferences September 8-12, 2003, Monticello, Illinois, USA http://hillside.net/conferences/plop.htm The European Pattern Languages of Programming conference June 25-29, 2003, Kloster Irsee, Germany http://hillside.net/conferences/europlop.htm Middleware 2003 June 16-20, 2003, Rio, Brazil www.cs.wustl.edu/ schmidt/activities-chair.html

Vanderbilt University

46

Vanderbilt University

47

OO Patterns

Douglas C. Schmidt

Summary
Mature engineering disciplines have handbooks that describe successful solutions to known problems e.g., automobile designers dont design cars using the laws of physics, they adapt adequate solutions from the handbook known to work well enough The extra few percent of performance available by starting from scratch typically isnt worth the cost Patterns can form the basis for the handbook of software engineering If software is to become an engineering discipline, successful practices must be systematically documented and widely disseminated
Vanderbilt University 48