Pattern Languages of Program Design 3 (v. 3) (Paperback)

~ (Author), Dirk Riehle (Author), (Author)

Editorial Reviews

Amazon.com Review

The third book in a series, Pattern Languages of Program Design 3 discusses how to catalog software patterns, which are reusable, higher-order designs. This volume presents over two dozen white papers on newly "discovered" patterns within a wide variety of contexts. The editors have grouped these patterns by topic so you can choose what interests you. Each pattern profile features a short introduction to show you what each pattern might be good for.

"General purpose" design patterns include the Null Object, the Manager, and the Product Trader patterns, and another section improves on the Visitor pattern. These patterns allow classes to borrow the methods of other classes without using inheritance. Some of the most challenging patterns in this book are good for distributed processing, including Acceptor and Connector and Object Recovery. Basic research in object-oriented design (OOD) is apparent in the Serializer pattern, which implements persistence for objects, another unusually difficult aspect of object design to get right. Another useful section introduces "domain specific" patterns--or patterns that solve particular real-world problems--with several patterns for transportation systems and fire alarms.

The book closes with more esoteric explorations of patterns for developers, including patterns for effectively designing in teams and using software testing patterns. Judging from the rich selection of the ordinary and the bizarre, there seems to be no end in sight for the business of discovering patterns. For those interested in expanding their collection of patterns, this volume offers a fascinating array of new specimens.

Review

Read the entire review of this book.

A software design pattern is a solution to a particular computing problem. Each pattern has, in general, four parts: the pattern name, the problem to be solved, the solution provided by the pattern, and the trade-offs. Familiarity with patterns makes software design "easier," because large concepts can be dealt with using the patterns, rather than reinventing the wheel in each program.

A recent presentation on patterns comes via Addison-Wesley's Corporate & Professional imprint. The production quality of Pattern Languages Of Program Design 3, edited by Robert Martin, Dirk Riehle, and Frank Buschmann, is excellent, and the binding easily endured the two months I spent reviewing the text. Most importantly, because you'll find yourself reading the text with pen in hand, the pages are of sufficient thickness to take marginalia and highlighting without bleed-through. This is a nice book...

PLoPD3 is no novel. It is a difficult book to read, for you are reading the documentation and code of other programs. It is not a book to skim once and shelve. Rather, I suggest you read a paper, try to imagine how you would use the pattern, and try some of the sample code. Try to imagine some of the problems that will occur if you use the pattern. With this admittedly conservative approach, the book will take a few months to read. --Peter N. Roth, Dr. Dobb's Journal -- Dr. Dobb's Journal

See all Editorial Reviews

Product Details

• Paperback: 656 pages
• Publisher: Addison-Wesley Professional (October 17, 1997)
• Language: English
• ISBN-10: 0201310112
• ISBN-13: 978-0201310115
• Product Dimensions: 9 x 7.3 x 1.5 inches
• Shipping Weight: 2.2 pounds (View shipping rates and policies)
• Average Customer Review: 4.3 out of 5 stars  See all reviews (3 customer reviews)
• Amazon.com Sales Rank: #765,205 in Books (See Bestsellers in Books)

Customer Reviews

Most Helpful Customer Reviews

4 of 4 people found the following review helpful:

4.0 out of 5 stars Enjoyable book for the friends of software patterns, March 11, 2005

By	ws__ (Hamburg, Germany) - See all my reviews

This book has quite some prerequisites for its potential readers. You should have a working knowledge of the patterns of the too basic books ("Design Patterns" by Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides and "Pattern-Oriented Software Architecture" by Frank Buschmann, Regine Meunier, Hans Rohnert, Peter Sommerlad, Michael Stal). It is helpful to have the too previous conference books as a reference nearby. Yes and you have to cope with C++ (when did you use it last time) and Smalltalk.

If you are happy with this, you get rewarded by a rich set of ideas and insights. The book just draws you in. This is a conference book by many authors. But due to their shepherd and writers workshop efforts the book nearly reads like being written by one author/author team. The level is excellent. Reading this book is a nice way to spend your time.

12 of 17 people found the following review helpful:

4.0 out of 5 stars A Lot of good stuff, December 29, 1999

By	Christophe Addinquy (Paris, France) - See all my reviews (REAL NAME)

When looking at the PLOPD serie, it become obvious that material become more and more mature. We'll find in this book good design patterns we can directly apply in our everyday work. Yo will probably found that all patterns are not usefull, but only a subset, but it's however an enough reason to buy this book.

1 of 1 people found the following review helpful:

5.0 out of 5 stars Many nuggets of software development knowledge, however you need some knowledge of design patterns to understand it, June 12, 2008

By	Charles Ashbacher "([e-mail])" (Marion, Iowa United States([e-mail])) - See all my reviews (TOP 50 REVIEWER)

While patterns are an inherent part of the human experience, using them in software development is a recent phenomenon. The seminal event was the publication of the book, "Design Patterns: Elements of Reusable Object-Oriented Software", by Erich Gamma, Richard Helm, Ralph Johnson, and John Vlissides. A Group so well-known that they are commonly referred to as the "Gang of Four," or GoF for short.
A design pattern is a metamodel for a solution. However, being a solution to a set of conditions common to many different problems, design patterns are very hard to learn. Even the GoF admit this in the preface of their book. "Don't worry if you don't understand this book completely on the first reading. We didn't understand it all on the first writing!" There are two fundamental reasons for this. The first is that the identification of a design pattern requires that one recognize a common abstraction among a set of abstractions. There is principle about great mathematicians that applies here. " The great mathematicians find analogies among analogies." The second is that our brains are very efficient at finding patterns. Unfortunately, those found are often ones already cataloged. Presented with a partial pattern, our minds automatically do a great deal of curve fitting to create a complete image matching one already known. Therefore, it is all too easy to find a pattern that we are familiar with, rather than the one that is present. Making the subject even more complex is that patterns are not distinctive entities. Some are constructed from other patterns, others are instances of a specific pattern, and many patterns share common characteristics. Being of recent vintage, there is no well-defined language available to describe patterns. Furthermore, not all patterns currently in use have been explicitly described.
As the name implies, the book being reviewed here is another volume in a series of collected works. In this case, the components are the best papers from PloP '96 and EuroPloP '96. They are of course of the highest quality, which means that intensive study is a precondition to understanding the book. Many new patterns are described, although at times one gets the impression that the word pattern is being overused. Without clear guidelines as yet for the precise use of the word in this context, this is expected. Very few of the patterns are described at the computer-code level, which is very good. Computer code, even when it is kept generic, eliminates some of the abstract qualities of what a pattern is designed to do. The pattern descriptions are given in the generic form: Intent, Motivation, Applicability, Structure, Participants, Collaborations, Known Uses, and Related Patterns.
This format allows for an understanding of all facets of the pattern, from the why of creation to how it fits into the dictionary of known patterns. The range of problems solved by these patterns is substantial. Some sample patterns are: Null Object, Bureaucracy, Bodyguard, Serializer, and the Selfish Class. In the final chapter, patterns on Patterns, an additional, important step up the metalevel hierarchy is taken. A definition and description language are described, although sentences like, "Patterns for making patterns Understandable contains patterns that capture techniques for making your patterns and pattern languages easier to read understand, and apply," require a great deal of thought. Patterns provide a series of levels of design structures that expedite the reuse of solutions, with code reuse being a direct consequence.
As more patterns are discovered and refined, and the description language is formalized, they will become the "gold standard" of software development. Learning what they are and how of implement them will become a highly valued skill. There are many nuggets to be mined from this book. However, be prepared to go slow and occasionally be discouraged.

Published in Journal of Object-Oriented Programming, reprinted with permission