 |
|
Title: Pattern-Oriented Software Architecture Volume 2: Patterns for Concurrent and Networked Objects
ISBN: 0471606952
Author:
Douglas Schmidt
Michael Stal
Hans Rohnert
Frank Buschmann
Publicate Date: 2000-09-14
Publish: 2000-09-14
List Price: $85.00
Average Customer Rating: 4.5
Format: Hardcover
 |
|
|
|
|
Amazon Lowest New Price: $48.35
Amazon Lowest Used Price: $28.60
Amazon Merchant Price: $68.00
|
|
|
|
|
|
|
|
|
|
|
| Customer Review: |
|
1: Book Chapters Available For Free From ACE Site
This is an excellent book, but the patterns (Connector, Acceptor, Acceptor-Connector, Reactor, Proactor, Half Sync-Half Async .....) are all available in MORE expansive (yes more expansive) form on the ACE site.
Just Google "ACE Framework" and you will see Doug Schmidt and his ACE related papers section which will conveniently list all the patterns in this book plus a ton more (yes more useful patterns NOT in this book). The related papers are ALL in PDF format and can be loaded into a PDF reader (see Altrix Illiad E-Book reader) or printed out to a bind. The sites PDF editions are extensively longer and more detailed than the book editions, so you are better off going to the site instead.
These is indeed an excellent reference, but considering that most of the patterns are now implemented in ACE (see ACE Programmers Guide) or even in Java (see Java 1.5 SE and up in the java.util.concurrent for concurrency).
The books C++ Network Programming Vol 1 and Vol 2 are much better and re-visit these patterns from which you can, again, get on the site for free and in a nice color illustrated edition (PDF).
Save your $70 and visit the ACE site.
|
2: Essential reading for programmers in its domain
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.
|
3: Simply the best
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.
|
4: Good information badly written
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.
|
5: Good Patterns Hidden in Excessive Verbiage
First, the patterns in this book are very good. It was nice to see some coverage of low level networking patterns. As an experienced programmer, I was vaguely familiar with many of the patterns already, but it is really helpful to see the lines drawn in the sand, to hear why the authors chose to break things up as they did, and to understand the ramifications of the patterns in greater detail (eg, their clarification of the difference between Observer and Interceptor was quite helpful). I even got to learn some new patterns! (The Leader / Followers pattern was new to me.)
That said, the writing style about drove me BANANAS! I have never lost my place in a sentence when reading a book so many times. I must have read every line twice. Look, I'm a computer geek - I LOVE dense technical books, but this is something else. It's like reading Shakespear, or Charles Dickens. The authors must have been paid by the word. The specific implies the general! Have mercy! I don't need the difference between an interface and its concrete implementation belabored every time it comes up (and in a patterns book, believe me it's often!)
|
|
|
|
|
