Patterns for Fault Tolerant Software (Wiley Software Patterns Series) [Hardcover]

Robert Hanmer (Author)

Book Description

ISBN-10: 0470319798 | ISBN-13: 978-0470319796 | Publication Date: December 18, 2007 | Edition: 1

Software patterns have revolutionized the way developer’s and architects think about how software is designed, built and documented.

This new title in Wiley’s prestigious Series in Software Design Patterns presents proven techniques to achieve patterns for fault tolerant software. This is a key reference for experts seeking to select a technique appropriate for a given system.

Readers are guided from concepts and terminology, through common principles and methods, to advanced techniques and practices in the development of software systems.  References will provide access points to the key literature, including descriptions of exemplar applications of each technique.

Organized into a collection of software techniques, specific techniques can be easily found with sufficient detail to allow appropriate choices for the system being designed.

Editorial Reviews

From the Back Cover

Patterns for Fault Tolerant Software is a welcome addition to Wiley's prestigious Series in Software Design Patterns.

Robert Hanmer, a Consulting Member of Technical Staff at Alcatel-Lucent, focuses on the software structures and mechanisms that can be designed into a system to enable its continued operation, even though a different part isn't working correctly.

Aimed at the novice as well as the experienced practitioner, the books ultimate goals is to provide you with proven techniques - in the form of patterns - to make programs less failure-prone when executing. The patterns included are divided into different groupings reflecting four main phases of fault tolerance:

• Error Detection
• Error Processing that consist of Error Recovery
• Error Mitigation
• Fault Treatment

as well as Architectural patterns that span these four phases.

Readers are guided from concepts and terminology, through common principles and methods, to advanced techniques and practices in the development of software systems. References provide access points to the key literature.

Patterns for Fault Tolerant Software provides you with a toolbox of techniques to build the fault tolerant patterns language needed to solve unique design problems.

Product Details

• Hardcover: 308 pages
• Publisher: Wiley; 1 edition (December 18, 2007)
• Language: English
• ISBN-10: 0470319798
• ISBN-13: 978-0470319796
• Product Dimensions: 9.3 x 7.7 x 0.9 inches
• Shipping Weight: 1.6 pounds (View shipping rates and policies)
• Average Customer Review: 4.0 out of 5 stars  See all reviews (2 customer reviews)
• Amazon Best Sellers Rank: #362,770 in Books (See Top 100 in Books)

More About the Author

Discover books, learn about writers, read author blogs, and more.

Customer Reviews

Most Helpful Customer Reviews

13 of 13 people found the following review helpful:

3.0 out of 5 stars Good as introductory material though still immature, February 19, 2008

By 

Alberto R. Gallardo Rico "skipper" (Germany) - See all my reviews

This review is from: Patterns for Fault Tolerant Software (Wiley Software Patterns Series) (Hardcover)

The book in its first edition is still immature: The content is not well structured; too many references break the reading flow; sections are not preceded with a section title, nor are the different sections explained.

The patterns presented are more of recipes or good practices than patterns as understood by GoF (Design Patterns: Elements of Reusable Object-Oriented Software (Addison-Wesley Professional Computing Series)) or POSA series (Pattern-Oriented Software Architecture Volume 1: A System of Patterns). The proposed solutions lack detail (e.g. "SOFTWARE UPDATE": it is not explained how to implement it), and there is no implementation tips.

It would be convenient adding more diagrams (preferably UML diagrams) to clarify relations between patterns (e.g. "FAULT OBSERVER" - "SOMEONE IN CHARGE" - "WATCHDOG" - "SYSTEM MONITOR"). This lack of diagrams makes more difficult trying to understand differences between the so-called "patterns".

The book is full of very simple pictures that are completely useless for understanding the patterns (some of them are really silly - it would be fine if they were placed in the margin, for example, but it's very annoying interrupting the text with these pictures and trying to force an explanatory text). The pictures could help remembering the stuff, but they are also referenced during the text, and these references break the reading flow.

The book contains some minor errors (e.g. the reference [DRS00] in the text refers to RFC 2278, when it should refer to RFC 2778).

Good point: last conclusion chapter provides a better picture of the "patterns" described in the book than any other chapter. From my point of view, is only after reading this chapter when the book makes sense.

As a conclusion, I found it interesting because it provides a common language for fault tolerant issues. It's useful as introductory material, but it needs some work, and I won't consider it a must-have book.

5 of 6 people found the following review helpful:

5.0 out of 5 stars Well written Patterns about a interesting domain, December 22, 2009

By 

Peter Sommerlad (Rapperswil, Switzerland) - See all my reviews
(REAL NAME)   

This review is from: Patterns for Fault Tolerant Software (Wiley Software Patterns Series) (Hardcover)

I used Bob's book "Patterns for Fault Tolerant Software" as reading material for my "Advanced Patterns and Frameworks" course. My students and me liked it very much. Not only is fault tolerance a domain not well covered by a typical informatics bachelor's program but also the writing style and presentation of the patterns in "Alexandrian form" made the patterns easy to read and follow. In contrast to the sole other reviewer, my students could cope with the networked structure of the pattern language easily and the diagrams visualizing the interconnection helped greatly to follow the interdependence of the patterns.

Each week the students prepared a section or a group of patterns and explained and discussed the patterns as a group in front of other student groups that had to prepare other pattern books. Not only the students actually reading Bob's book, but also the students from the other groups got a great overview on the domain of fault tolerance. They often could relate the patterns from the book to their own experience and knowledge gained in other courses, i.e., on computer networks, and thus strengthen their understanding in both areas.

From a pattern perspective, I liked the "Alexandrian" approach as performed by Bob Hanmer very much, because in contrast to my own pattern writing style it suits better for "smaller" and interconnected patterns forming a pattern language. The pictures and visuals help a lot in memorizing and understanding the concepts behind the individual patterns.