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.
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.
