Make your own free website on


General | Movings | My favourite sites | My Background | My Latest Stuff | Black scientists | Greatings .. | Languages | Distributing | Designing | Telecommunication | Peoples | Research | Publications


Software Design Patterns,  What's that ? 

 In "Understanding and Using Patterns in Software Development", Dirk Riehle and Heinz Zullighoven give a nice definition of the term "pattern" which is very broadly applicable:

A pattern is the abstraction from a concrete form which keeps recurring in specific non-arbitrary contexts.

The above authors point out that, within the software patterns community, the notion of a pattern is "geared toward solving problems in design." More specifically, the concrete form which recurs is that of a solution to a recurring problem. But a pattern is more than just a battle-proven solution to a recurring problem. The problem occurs within a certain context, and in the presence of numerous competing concerns. The proposed solution involves some kind of structure which balances these concerns, or "forces", in the manner most appropriate for the given context. Using the pattern form, the description of the solution tries to capture the essential insight which it embodies, so that others may learn from it, and make use of it in similar situations. The pattern is also given a name, which serves as a conceptual handle, to facilitate discussing the pattern and the jewel of information it represents. So a definition which more closely reflects its use within the patterns community is:

A pattern is a named nugget of instructive information that captures the essential structure and insight of a successful family of proven solutions to a recurring problem that arises within a certain context and system of forces.
A slightly more compact definition which might be easier to remember is:
A pattern is a named nugget of insight that conveys the essence of a proven solution to a recurring problem within a certain context amidst competing concerns.
Patterns are usually concerned with some kind of architecture or organization of constituent parts to produce a greater whole. Richard Gabriel, author of Patterns of Software: Tales From the Software Community, provides a clear and concise definition of the term pattern in the Patterns Definitions section of the Patterns Home Page:
Each pattern is a three-part rule, which expresses a relation between a certain context, a certain system of forces which occurs repeatedly in that context, and a certain software configuration which allows these forces to resolve themselves.
As Gabriel explains, Alexander describes it a bit more colorfully in [TTWoB]:
Each pattern is a three-part rule, which expresses a relation between a certain context, a problem, and a solution.
As an element in the world, each pattern is a relationship between a certain context, a certain system of forces which occurs repeatedly in that context, and a certain spatial configuration which allows these forces to resolve themselves.
As an element of language, a pattern is an instruction, which shows how this spatial configuration can be used, over and over again, to resolve the given system of forces, wherever the context makes it relevant.

The pattern is, in short, at the same time a thing, which happens in the world, and the rule which tells us how to create that thing, and when we must create it. It is both a process and a thing; both a description of a thing which is alive, and a description of the process which will generate that thing (p. 247).

In Software Patterns, esteemed "patternite" Jim Coplien writes:
I like to relate this definition to dress patterns. I could tell you how to make a dress by specifying the route of a scissors through a piece of cloth in terms of angles and lengths of cut. Or, I could give you a pattern. Reading the specification, you would have no idea what was being built or if you had built the right thing when you were finished. The pattern foreshadows the product: it is the rule for making the thing, but it is also, in many respects, the thing itself.
So we see that a pattern involves a general description of a recurring solution to a recurring problem replete with various goals and constraints. But a pattern does more than just identify a solution, it also explains why the solution is needed!

Patterns for software development are one of the latest "hot topics" to emerge from the object-oriented community. They are a literary form of software engineering problem-solving discipline that has its roots in a design movement of the same name in contemporary architecture, literate programming, and the documentation of best practices and lessons learned in all vocations.
Fundamental to any science or engineering discipline is a common vocabulary for expressing its concepts, and a language for relating them together. The goal of patterns within the software community is to create a body of literature to help software developers resolve recurring problems encountered throughout all of software development. Patterns help create a shared language for communicating insight and experience about these problems and their solutions. Formally codifying these solutions and their relationships lets us successfully capture the body of knowledge which defines our understanding of good architectures that meet the needs of their users. Forming a common pattern language for conveying the structures and mechanisms of our architectures allows us to intelligibly reason about them. The primary focus is not so much on technology as it is on creating a culture to document and support sound engineering architecture and design.


A bit of Patterns History

The events described here are related in more detail in the HistoryOfPatterns pages at Ward Cunningham's WikiWiki Web.
In 1987, Ward Cunningham and Kent Beck were working with Smalltalk and designing user interfaces. They decided to use some of Alexander's ideas to develop a small five pattern language for guiding novice Smalltalk programmers. They wrote up the results and presented them at OOPSLA'87 in Orlando in the paper "Using Pattern Languages for Object-Oriented Programs".
Soon afterward, Jim Coplien (more affectionately referred to as "Cope") began compiling a catalog of C++ idioms (which are one kind of pattern) and later published them as a book in 1991, Advanced C++ Programming Styles and Idioms.

From 1990 to 1992, various members of the Gang of Four had met one another and had done some work compiling a catalog of patterns. Discussions of patterns abounded at OOPSLA'91 at a workshop given by Bruce Andersen (which was repeated in 1992). Many pattern notables participated in these workshops, including Jim Coplien, Doug Lea, Desmond D'Souza, Norm Kerth, Wolfgang Pree, and others.

In August 1993, Kent Beck and Grady Booch sponsored a mountain retreat in Colorado, the first meeting of what is now known as the Hillside Group. Another patterns workshop was held at OOPSLA'93 and then in April of 1994, the Hillside Group met again (this time with Richard Gabriel added to the fold) to plan the first PLoP conference.

Object-Oriented System Development    (Dennis de Champeaux, Doug Lea & Penelope Faure)
The original hardcover textbook edition (ISBN 0-201-56355-X) of Object-Oriented System Development was published by Addison Wesley, copyright © 1993 by Hewlett-Packard Company. All parties involved have graciously granted permission to create this HTML edition, maintained by Doug Lea. The following links inserted below has been taken out of Doug's page and it gives a summary of the books contents. A very intersting book's about Designing and Modelling Process for large projects.
Part 1: Analysis 
- Introduction to Analysis 
Purpose; Models; Process; Summary
- Object Statics 
Instances; Classes; Attributes; Attribute Features; Constraints; Identifying Objects and Classes; Summary
- Object Relationships 
Relationships; Collections; Identifying Relationships; Summary
- Object Dynamics 
Describing Behavior; Transition Networks; Examples; Reducing Complexity; Summary
- Object Interaction 
Transitions; Sending and Receiving Events; Interaction Notations; Examples; Summary
- Class Relationships 
Property Inheritance; Subclasses; Multiple Inheritance; Sibling Relationships; Set Operations; Inheritance of Relations; Summary
- Instances 
Subclasses and Instances; Metaclasses; Parametric Instances ; Summary
- Ensembles 
Ensembles; Other Decomposition Constructs; Ensembles as Systems; Summary
- Constructing a System Model 
Requirements Fragment; Use Cases; Subsystems; Vocabulary; Classes; Ensembles; Model; Summary
- Other Requirements 
Resources; Timing; Other Constraints; Summary
- The Analysis Process 
Software Development Process; Default Sequence of Steps; OO Analysis of the OO Analysis Process; Alternative Processes; Tools; Summary
- Domain Analysis 
Models; Reuse; Summary
- The Grady Experience 
Part II: Design 
- From Analysis to Design 
Continuity; Transformation; Design Phases; Design Criteria; Managing Design; Summary
- Description and Computation 
Translating Analysis Models; From Abstract to Concrete; Composing Classes; Controlling Transitions; Generic Classes; Generating Instances; Design for Testability; Transformation and Composition; Summary
- Attributes in Design 
Defining Attributes; Concrete Attributes; Views; Exports; Composition and Inheritance; Summary
- Relationships in Design 
Relationships; Collections; Coordinators; Relations versus Composites; Summary
- Designing Transitions 
States and Guards; Atomicity; Timing Constraints; Concrete Transitions; Summary
- Interaction Designs 
Callbacks; Replies; Invocations; Control Flow; Summary
- Dispatching 
Selection; Resolution; Routing; Summary
- Coordination 
Joint Actions; Controlling Groups; Open Systems; Summary
- Clustering Objects 
Clustering; Cluster Objects; System Tools and Services; Persistence; Summary
- Designing Passive Objects 
Transformations; Storage Management; Passive Objects in C++; Summary
- Performance Optimization 
Optimization and Evolution; Algorithmic Optimization; Performance Transformations; Optimization in C++; Summary
- From Design to Implementation 
Testing; Performance Assessment; Summary; 
Below further Links && Sites of Interest about Designing 

Doug Lea's "Patterns-Discussion FAQ
Doug Lea's paper, "Christopher Alexander: An Introduction for Object-Oriented Designers" 
Dirk Riehle and Heinz Zullighoven's "Understanding and Using Patterns in Software Development" 
Doug Schmidt and Ralph Johnson's introduction to the October 1996, CACM Special Issue on patterns 
Excerpts from Jim Coplien's SIGS management briefing Software Patterns
Jim Coplien's paper "Software Design Patterns: Common Questions and Answers" 
John Vlissides' article "Patterns: The Top 10 Misconceptions" in the March 1997 Object Magazine Online
The "History of Patterns" on Ward Cunningham's WikiWiki Web 
"Pattern Definitions" from the Patterns Home page 
Steve Berczuk's "Finding solutions through pattern languages" 
"Some Notes on Christopher Alexander", by Nikos A. Salingaros
"Design Patterns: Elements of Reusable Architectures", by Linda Rising 
Brian Kurotsuchi's Design Patterns Tutorial 
Ravi Palepu's "Modelling the Real World: Application of Patterns to Reduce Complexity in the Software Development Process"
Doug Schmidt's "Pattern Writer's Workshop Tutorial" 
Ward Cunningham's "Tips for Writing Pattern Languages" on the WikiWiki Web 
"A Pattern Language for Pattern Writing" by Gerard Meszaros and Jim Doble 
Richard Gabriel's article "Developing Patterns Studies" from InfoWorld on-line 
A "Patterns BookList" on the WikiWiki Web 
The Patterns Home Page 
The Portland Pattern Repository 
Ward Cunningham's wonderful WikiWiki Web 
Patlets FrontPage - a Patterns Database 
Cetus Links: Patterns, hundreds of links to pattern-related pages 
Brad Appleton's "Software Patterns Links" 
AG Communications Systems Patterns Pages 
The OrganizationPatterns FrontPage
The "Design Patterns Mailing Lists by thread" 
The "Organization-patterns Mail Archive by thread" 
Patterns Central Site
Patterns Home Page (Eric Huss)
Wiki Wiki Web
Portland Pattern Repository (Ward Cunningham)
AntiPatterns (KeithDerrick)
Best Pattern Threads
History of Patterns
PeopleIndex (Ward Cunningham)
ProjectIndex (Ward Cunningham)
Book List
Patterns Tutorials Patterns General Articles Projects about Patterns
Special Articles about Patterns
Conferences, Workshops, Archives and Products
Languages and Diverses ..
Conferences Workshops Utilities / Tools Products / Companies Archives Patterns and Pattern Languages Rules, and Creativity (All Links);