Customer Reviews

Pattern Languages of Program Design 5

5 star:		(1)
4 star:		(2)
3 star:		(1)
2 star:		(0)
1 star:		(0)

 

 

"Pattern Languages of Program Design 5" is the latest in a series output by the PLoP (pattern languages of programming) conferences. A pattern language is a group of higher order design patterns that go together to form a vocabulary for a specific problem.

Each chapter stands on its own and is written by different people. This makes the format all over the place - each chapter is somewhat different. Some of the content is fairly specialized. There are chapters on real time systems, radio and pattern writing. While all of these are fascinating, they are unlikely to appeal to the same group of practicing developers.

At times, the book feels academic. It is probably supposed to as it is on introducing new patterns to the world. I felt there was a strong emphasis on contributing to PLoP and writing new patterns.

That said, each chapter was very good on its own. The authors were all interesting and explained the topic clearly. There were good examples and the quality was high.

I recommend this book if interested in PLoP or pattern writing in general. If you've read #4 in the series, you will definitely find this one enjoyable. If not, I would recommend starting with #1 in the series. There are some backward references to earlier books, so it would be easier to follow.

Software patterns have been a seminal idea whose merit is now considered axiomatic by most experienced programmers. The authors of this book have been part of the patterns community for several years. Yes, there certainly is such a thing as a patterns community, with regularly held conferences, designated PLoP, as in the book's title.

The book is essentially an update of what the authors consider to be new and useful patterns, since the previous book in this series. Which is actually a useful way to measure progress in this field. Akin perhaps to some science journals that describe better modelling or understanding of some natural phenomena. In the introduction, the authors remark that now there are several thousand published patterns! Isn't that amazing? A tribute to the power of the idea. But this proliferation also can lead to confusion. A metalanguage is needed to classify the patterns. And expert knowledge to discern which are or might be the most useful patterns. The remit of this book is to try to address the latter need. But it also provides several chapters on how to describe patterns in a consistent manner.

The patterns span quite diverse applications. Reflects the many uses of software. One chapter talks about MoRaR, which is for designing wireless software. There are issues here of a limited geographic reach of devices, and intermittent and low bandwidth linkages. Constraints that need to be addressed by some patterns.

Another chapter ventures into patterns for plug-ins. This perhaps reflects the popularity of Eclipse as a Java IDE. Or, more generally, of designing a software infrastructure flexible enough to accomodate many developers.

This book offers you, the software engineer, the opportunity to learn from the hard won experience of some very elite engineers. That experience has been documented, shepherded, peer-reviewed, further refined, edited, and refined again. I wish I could succinctly communicate my object-oriented designs as cogently and as comprehensively as shown here. I know engineers at MIT Lincoln laboratory that could benefit from this book.

This scholarly work of computer science advances the state of the art in object oriented design. You are looking at the best of the best of pattern languages (patterns that are made up of design patterns) over a period of about four to five years. It is unusual for a book to have a single idea or idiom, on which, you could base an entire software product. This book provides more than one or two such ideas. It provides fertile ground to create a range of products that provide an competitive advantage in the market place.

Most organizations have standardized on one to three languages that are acceptable for use building enterprise-grade applications. My particular favorite pattern language, the Dynamic Object Model, is worth the price of the book alone if you are a software engineer tasked with supporting an analyst or customer with very vague requirements using a relatively static language. Turn those vague needs into an incredibly flexible system to explore those requirements while keeping maintenance costs under control.

If you must use a relatively static language (Java, C++, C#) and need to get more dynamic (like inserting new types or fields into objects at runtime) the Dynamic Object Model pattern language is for you. Not all of us are allowed to benefit from features commonly found in higher-level languages like Python or Smalltalk. This pattern language helps us trade speed for design flexibility. Advice is also given on borrowing virtual machine technology to speed our flexible implementations.

The reference to a Master's thesis describing a system, based on the Dynamic Object Model, that provides an editor for relational databases is invaluable if you have a need for providing such a capability for a non-technical end user.

I was particularly pleased with the GRID pattern language and distributed workflow plattern language. The ideas (groupings of patterns) are plainly stated, obvious in their value, extraordinarily written, and demonstrated in as little code as possible (often less than 200 lines).

If you are focused on learning APIs and certifying for various technologies this book is NOT for you. There are enough projects that work very well in a particular vendor's paradigm (create form, publish, use; or three tier MVC-based architecture).

If your software development needs aren't completely met by a vendor's solution paradigm, or if you are focused on expanding your understanding of problem solving through object oriented design and implementation then you have already cheated yourself by not buying this book. Creating proof of concept prototypes based on the sample code and adapting the designs to your own domain will take YEARS off your learning curve.

Very few patterns books are this accessible. If you are serious about creating "outside the box" object oriented systems you should do yourself a favor and consider this book.

For those who are very into design patterns, here's a book that explores some new specialized patterns by industry players... Pattern Languages of Program Design 5, edited by Dragos Manolescu, Markus Voelter, and James Noble.

Contents:
Part 1 - Design Patterns: Dynamic Object Model; Domain Object Manager; Encapsulated Context
Part 2 - Concurrent, Network, and Real-Time Patterns: A Pattern Language for Efficient, Predictable, and Scalable Dispatching Components; "Triple -T" - A System of Patterns for Reliable Communication in Hard Real-Time Systems; Real Time and Resource Overload Language
Part 3- Distributed Systems: Decentralized Locking; The Comparand Pattern - Cheap Identity Testing Using Dedicated Values; Pattern Language for Service Discovery
Part 4 - Domain-Specific Patterns: MoRaR - A Pattern Language for Mobility and Radio Resource Management; Content Conversation and Generation on the Web - A Pattern Language
Part 5 - Architecture Patterns: Patterns for Plug-ins; The Grid Architectural Pattern - Leveraging Distributed Processing Capabilities; Patterns of Component and Language Integration; Patterns for Successful Framework Development
Part 6 - Meta-Patterns: Advanced Pattern Writing; A Language Designer's Pattern Language; The Language of Shepherding; Patterns of the Prairie Houses
About the Authors; Index

By no means were the 23 original patterns first published over a decade ago in the Gang of Four book meant to be the definitive list of patterns. They are the most common and applicable to general development. But over that decade, technology and software development has progressed, and new situations that have patterns have emerged. This book is a series of papers published as part of the Pattern Languages of Programming (PLoP) conferences. They've been edited and compiled into a standard format and offered in this single volume. On the positive side, the tight editing means that you have a fair amount of consistency in terms of style and formatting. You get sections for examples, context, problem, solution, implementation, consequences, known uses, related patterns, conclusion, acknowledgements, and references. I like the layout, in that it's easy to quickly determine what the pattern is attempting to solve, and whether it's something you could use...

The negative on compilation books is that your needs may not mesh up with the content chosen for inclusion. In this case, you may find the entire Part 2 section is irrelevant since you don't program or develop in those domains. Still, this compilation is better than most in that it's presented in a reference style which could be kept around for potential use down the road. It's not as if it's the ramblings of someone's thoughts that might not age well...

Solid material for those who have already grasped the pattern concept, and even better if you see something in here that sparks an interest...