- Hardcover: 666 pages
- Publisher: Wiley; Volume 2 edition (September 14, 2000)
- Language: English
- ISBN-10: 0471606952
- ISBN-13: 978-0471606956
- Product Dimensions: 7.7 x 1.6 x 9.6 inches
- Shipping Weight: 3.1 pounds
- Average Customer Review: 25 customer reviews
- Amazon Best Sellers Rank: #924,680 in Books (See Top 100 in Books)
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.
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.
See the Best Books of 2017
Looking for something great to read? Browse our editors' picks for the best books of the year in fiction, nonfiction, mysteries, children's books, and much more.
Customers who bought this item also bought
What other items do customers buy after viewing this item?
"This book is one of the more important contributions to the literature on 'patterns' and deserves to become a standard text on its specified area of interest."
-- 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
Designing application and middleware software to run in concurrent and networked environments is a significant challenge to software developers. The patterns catalogued in this second volume of Pattern-Oriented Software Architecture (POSA) form the basis of a pattern language that addresses issues associated with concurrency and networking. The book presents 17 interrelated patterns ranging from idioms through architectural designs. They cover core elements of building concurrent and network systems: service access and configuration, event handling, synchronization, and concurrency. All patterns present extensive examples and known uses in multiple programming languages, including C++, C, and Java. The book can be used to tackle specific software development problems or read from cover to cover to provide a fundamental understanding of the best practices for constructing concurrent and networked applications and middleware.
Top customer reviews
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.
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.
Most recent customer reviews
Although the documented patterns suit server and client applications, I would have prefered to see them...Read more