Pattern-Oriented Software Architecture Volume 2: Patterns for Concurrent and Networked Objects Volume 2 Edition

by Douglas Schmidt (Author), Michael Stal (Author), Hans Rohnert (Author),

24 customer reviews

ISBN-13: 978-0471606956

ISBN-10: 0471606952

Why is ISBN important?

Have one to sell? Sell on Amazon

Share <Embed>

Rent

$26.02

Due Date: Aug 13, 2018 Rental Details

FREE return shipping at the end of the semester.
Access codes and supplements are not guaranteed with rentals.

In Stock. Rented from Amazon Warehouse , Fulfilled by Amazon

List Price: $95.00 Save: $68.98 (73%)

Free Shipping

Add to Rental Cart

Price

New from

Used from

Kindle

"Please retry"

$61.59

—

Hardcover

"Please retry"

—

$92.82

$24.99

Digital, Amazon Upgrade

"Please retry"

$16.00

—

Free%20Two-Day%20Shipping%20for%20College%20Students%20with%20Amazon%20Student

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 Architectures (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.

About the Authors

This book has been written by the award winning team responsible for the first POSA volume "A System of Patterns", joined in this volume by Douglas C. Schmidt from University of California, Irvine (UCI), USA.

Visit our Web Page

Editorial Reviews

Review

"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.

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: 24 customer reviews
Amazon Best Sellers Rank: #448,783 in Books (See Top 100 in Books)
- #133 in Books > Textbooks > Computer Science > Object-Oriented Software Design
- #192 in Books > Computers & Technology > Business Technology > Management Information Systems
- #194 in Books > Computers & Technology > Hardware & DIY > Design & Architecture

Would you like to tell us about a lower price?
If you are a seller for this product, would you like to suggest updates through seller support?

NO_CONTENT_IN_FEATURE

Start reading Pattern-Oriented Software Architecture, Patterns for Conc... on your Kindle in under a minute.

Don't have a Kindle? Get your Kindle here, or download a FREE Kindle Reading App.

Important information

Ingredients

Example Ingredients

Directions

Example Directions

Customer Reviews

1 star (0%)

Write a customer review

See all 24 customer reviews

Read reviews that mention

Top customer reviews

There was a problem filtering reviews right now. Please try again later.

Ting L

Great book on concurrent system design.

March 24, 2017

Format: HardcoverVerified Purchase

I read this book briefly in the past. But recently, I have thoroughly re-studied this book in about two months time. The book is an old grandma book in the computer age. But interestingly, the ideas and design principles are still very applicable when working on complex concurrent systems. The patterns described in the book such as Active Object/Proactor/Async Completion Token/Interceptor/Half Sync & Half Async are used extensively in my daily work. By reading the book, I have a new level of understanding on these patterns.

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.

One person found this helpful

Comment

December 12, 2000

Format: HardcoverVerified Purchase

With so many patterns books out there written by little pikers who've probably never worked on a codebase of more than a thousand lines, this is a gust of fresh air. The first volume in this series is one of the great patterns books. The only knock I could offer on this book is that it is slanted a little toward the net equivalent of a kernel mechanic: in this day and age of the container as king, not many of us are doing thread locking on sockets (thank you Sun!<g>). That said, these are intelligent examinations of patterns that are very realistic. I just reread the section on asynchronous notification mechanisms and the trade-offs between implementing a 'double observer' and other variations and was struck by the degree to which the material had been thought through and all the logical dependencies intelligently communicated. If you want to see what patterns look like when they are in the hands of seriously bright people, not some book junk of the month JC dropout, tune in here.

9 people found this helpful

Comment

October 12, 2016

Format: HardcoverVerified Purchase

Thanks

Helpful

Not Helpful

Comment

Nobody's Business

Good information badly written

April 8, 2005

Format: HardcoverVerified Purchase

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.

4 people found this helpful

Comment

February 24, 2013

Format: HardcoverVerified Purchase

Got this as a Christmas gift for my boyfriend. He is reading it at the moment and keeps telling me how much he loves this book. He is going for his PhD in Computer Science and currently doing research with mobile applications. Apparently this book is helping him a lot. Also helps to know his professor is the author of this book.

Helpful

Not Helpful

Comment

Size does matter

October 27, 2004

Format: Hardcover

Big problems really are different from small problems. Solutions to small problems rarely scale well - the big solution often has to be different in kind from the small one. This book is about solutions to big problems, the kind that may involve hundreds of servers and thousands of clients, or more.

This gives a clear, thorough description of about 15 design patterns that work well large, performance-sensitive applications. Some (like "Scoped Locking") depend on the specific semantics of C++, but may work in Java or C# if used carefully. Others are highly specialized implementations of more general patterns. The "Leader/Followers" pattern, for example, is a one implementation of the "Object Pool" pattern (see Grand, 'Patterns in Java', 1998) used for a particular purpose. On the whole, the authors did a fair job of relating these patterns to others in the literature. I was only occasionally frustrated that I did not have that literature at hand when reading this.

The authors go into extreme detail in describing implementations based on each pattern, something sure to help some readers. There is often a C++ implementation as well, at least in skeletal form. The descriptions go on at great length, averaging almost thirty pages of discussion for each pattern. More isn't necessarily better, though, and some descriptions would have benefitted from a slimming program. I would also have been grateful for more differential discussion - comparing patterns, in terms of the specific decision critieria that argue for one pattern vs. another.

The back matter in this book takes about 100 pages - glossary, bibliography, and indices by pattern, topic, and author names. Very helpful stuff. If it's going to be that long, however, a sentence or two about the more important references would have added little bulk but lots of value to the bibliography.

The book is a good one, giving lots of practical information about the patterns it discusses. It's aimed at an experiecned reader, someone already conversant with OO programming, patterns, and at least a taste of problems bigger than classroom exercises or solo projects. A bit less mass chosen a bit more carefully would have improved this book, but it's still a worthwhile addition to my technical library.

//wiredweird

2 people found this helpful

Helpful

Not Helpful

Comment