on 30 April 2001
Many design patterns are intended for use in applications. In contrast, this book presents patterns which may be used in applications, but which are of much more use in developing server software or middleware.
The book introduces patterns and pattern languages, presents a synopsis of the past, present, and future of patterns, and has an ample bibliography. However, the bulk of the text describes particular patterns in four groups.
1. Server access and configuration patterns are concerned with making services available to applications via OO interfaces as well as configuring applications dynamically.
2. Event handling patterns were, for me, the highlight of the book. These address alternative schemes for passing events to applications.
3. Synchronization patterns deal with ways of handling locking and will probably be fairly familiar to server developers.
4. Concurrency patterns describe ways of structuring a system into multiple threads in an OO style.
The concepts and abstractions presented are very helpful, but are also described in concrete terms. For example, the Reactor pattern talks about demultiplexing and dispatching service requests but the description goes right down to the level of a TCP/IP select operation. In short, the descriptions are useful for novice and expert alike as layers of detail are added to each pattern in a predictable order. This makes it easy to understand each pattern and skip the low-level implementation details on a first reading.
If you work on software servers, middleware, communications software, or distributed applications, I recommend that you read this book.
on 13 July 2001
A very well written book. The authors have all the relevant experience. All the patterns are even described using a pattern (hmmm!)
I found that one needs to _study_ the book and then rework the examples to fully appreciate the power of those patterns. To me, the Variations sections made lots of sense _after_ studying each pattern. I already feel empowered (to use a corporate term) with many new tricks and ideas that often seemed to be known only by very few.
However two things I think could be improved:
1) The patterns often tend to be wordy and repetitive (but one might argue that that serves to illustrate the point better.) 2) Example code for each pattern is distributed (hmm!) among many pages making it difficult to see how all parts fit together. I believe an extra section containing a fully worked example will enable people to immediately reuse those patterns.
on 30 June 2013
The enduring popularity of this excellent book can be seen from the fact that it has been reprinted 11 times in as many years! I bought it to use as my main textbook for the Coursera 'Pattern-Oriented Software Architectures for Concurrent and Networked Software' course, and it turned out to be one of the best buys I've ever made.
The patterns in the book fall into four categories: Server Access and Configuration, Event Handling, Synchronization and Concurrency. Although each pattern is laid out in the classic way, the book is notable in that for each pattern it not only describes the problem to be solved, the details of the solution, and where it fits into architecture decisions, but also explains, with examples, how to code the pattern.
This book is, to my mind, one of the finest examples of how a patterns book should be written.
I wrote my first networking code, in 'C' in 1985, and I've been using variants of that code on and off ever since - mainly in C++. When I read the event handling section of this book, I realized that I'd written code that implemented the Reactor and the Acceptor-Connector patterns, though I'd partially fused them together. As a result, I have a much better understanding of what I did and I am in a position to refactor my code to disentangle the two patterns, making the code more efficient, easier to reuse, and better encapsulated.
Other sections of the book have given me ideas on concurrency and locking that mesh with the programs I'm currently working on. Finally there is an important, though brief, discussion on pattern languages. When I first saw the section entitled 'From Individual Patterns to Pattern Languages' in the book's index, I groaned - visions of complex UML diagrams flashing through my mind. Thus it came as a pleasant surprise to discover that Pattern Languages are about how you put patterns together to form larger entities, such as more complex patterns, component, libraries and modules.
I really would recommend this book to working programmers. Sooner or later you are bound to need to write networked and/or concurrent software. Even chips destined for real time use are starting to come in multi-core configurations these days. The code examples are mostly in C++, but any programmer fluent in a 'C' based language should be able to follow them without any problems.