I recently finished reading Pattern Oriented Software Architecture Vol 2: Patterns for Networked and Concurrent Objects. Believe it or not, it took me just one night to read this book cover to cover. The main reasons behind this are that a) the techniques described in this book are already well known to people working in a company that deals with some of the largest network applications in the world, and b) the book itself is very well written.

The really nice thing about this book is the way in which the patterns are presented. I was thoroughly impressed with how, for each pattern, the authors start with describing the problems and constraints. The solution is then presented with a static, object view. This is follwed by a dynamic view with a UML sequence diagram that shows how the pattern works at run-time. This is followed by detailed textual description of the steps required to implement the pattern, along with code snippets. Lastly, there's a list of real-world software implementations that have used the respective patterns, and one example from real life. The real life example is on occasion so instrumental in understanding the purpose and/or workings of the pattern that it could make you exclaim, "a-ha!".

Many of the patterns, like Wrapper Facade, Scoped Locking Idiom, Thread-safe Interface, Half-Sync/Half-Async, Leader/Followers, etc. are easy to follow and likely already known to people dealing with networked applications. The most insane patterns that I found were Proactor (for asynchronous demultiplexing and handling of events) and Interceptor (for event based access to the internals of a framework in a safe manner). They have the potential of making you start hating frameworks! About half of the patterns were new for me.

If you really want to understand concurrent networked systems, this is the book. It codifies things that have only been known as "black magic" in the past. I have used these concepts in code that I have written, and the results are amazing. It is quite focused on ACE, so you will get the most benefit out of it if you use ACE, but the concepts are presented generally so that using ACE is not required.

This book summarizes some important distributed systems patterns researchers have identified in recent years. In that sense it is a necessary contribution to the software engineering literature.

However, the examples are at times unclear and the author does not always motivate them convincingly. From a technical writing perspective, the passive voice plagues this book from start to end, forcing readers to stop and reread sections to make sense of convoluted prose.