Pattern-Oriented Software Architecture Volume 2: Patterns for Concurrent and Networked Objects Volume 2 Edition
Use the Amazon App to scan ISBNs and compare prices.
Enter your mobile number or email address below and we'll send you a link to download the free Kindle App. Then you can start reading Kindle books on your smartphone, tablet, or computer - no Kindle device required.
To get the free app, enter your mobile phone number.
Frequently bought together
-- Overload, September 2000
"Let me Start by saying that I highly recommend this book. If you are a reader of the expanding literature on pattern-oriented software design, rush out and buy this book! This book has the potential to be a seminal volume." --Glenn E. Mitchell II, Ph.D.: Microsoft Office Pro; www.msofficepro.com; (5/30/01)
From the Back Cover
- Publisher : Wiley; Volume 2 edition (September 14, 2000)
- Language : English
- Hardcover : 666 pages
- ISBN-10 : 0471606952
- ISBN-13 : 978-0471606956
- Item Weight : 3 pounds
- Dimensions : 7.7 x 1.6 x 9.55 inches
- Best Sellers Rank: #1,309,287 in Books (See Top 100 in Books)
- Customer Reviews:
Top reviews from the United States
There was a problem filtering reviews right now. Please try again later.
That being said, the author has been very wordy when explaining a simple idea and some of the examples are bit confusing. To fully grasp the ideas of the patterns, readers need patience and might have to review it a few times. More importantly, the examples used to illustrate patterns are tightly tied to a particular OS feature and make the pattern less meaningful in a broad sense. In fact, many patterns described in the book can be applied to a wider and more general context. For example, Acceptor/Connector can be applied to telephony application e.g. SIP or P2P communications systems to model the initiator and receiver. The Proactor/Async Completion Token can be applied to build electronic trading system where orders are filled asynchronously, also async operation processor within the Proactor can be implemented in the application level. In addition, the downloadable papers from author's web site explain acceptor/connector and leader/follower patterns (e.g. Bound variant etc) better than the book though the book explains other patterns well.
Comparing with GOF book, this book has illustrated some of the architectural level patterns which minimize locking and increase the efficiency for concurrent system. Surprisingly, this book receives much less reviews comparing to GOF design pattern books which is more related to micro level design strategies. I believe that this book is heavily under-rated.
After finishing the book, I like the book very much and bought a used one for a much cheaper price than the original $90 so I can have all patterns in one collection. Overall, it is a great book and highly recommended.
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.
Top reviews from other countries
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.