Reviews for Pattern-oriented Software Architecture Vol 2: Patterns for Concurrent and Networked Objects

1. Brilliant book !

   Rated 5 out of 5 stars, July 12th, 2001

   A must read for anyone developing system software. The book explains event handling, synchronization and threading pattern with a very practical example.

2. The nitty gritty of distributed programming

   Rated 5 out of 5 stars, July 12th, 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.

3. Making concurrent programming practical

   Rated 5 out of 5 stars, May 12th, 2001

   Concurrent programming used to be a rather theoretical subject. Using non-comercial or non-wide used platforms. This book makes the subject really useful. Lots of practical examples.

   I'm using the material as part of the course on Object Oriented Software Engineering that I give at the University.

4. Design patterns for system software

   Rated 5 out of 5 stars, April 12th, 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.