|
||||||||||||||||||||
|
||||||||||||||||||||
|
||||||||||||||||||||
 Gutschein erhalten
Tauschen Sie jetzt Patterns for Fault Tolerant Software (Wiley Series in Software Design Patterns) gegen einen Amazon-Gutschein in Höhe von EUR 7,65 ein - einlösbar für Tausende von Artikeln bei Amazon.de. Entdecken Sie mehr eintauschbare Bücher im Bücher Trade-In Shop. Bitte beachten Sie die Teilnahmebedingungen.
 Jetzt für Amazon Student anmelden und um 20% erhöhten Eintauschwert sichern. |
Wird oft zusammen gekauft
Produktinformation
Möchten Sie die Produktinformationen aktualisieren oder Feedback zu den Produktabbildungen geben?
Ist der Verkauf dieses Produkts für Sie nicht akzeptabel? |
Mehr über den Autor
Entdecken Sie Bücher, lesen Sie über Autoren und mehr
› Besuchen Sie die Seite von Robert S. Hanmer auf Amazon
› Besuchen Sie die Seite von Robert S. Hanmer auf Amazon
Produktbeschreibungen
Kurzbeschreibung
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.
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.
Synopsis
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.
Welche anderen Artikel kaufen Kunden, nachdem sie diesen Artikel angesehen haben?
In diesem Buch
(Mehr dazu)
Ausgewählte Seiten ansehen
Buchdeckel | Copyright | Inhaltsverzeichnis | Auszug | Stichwortverzeichnis
Buchdeckel | Copyright | Inhaltsverzeichnis | Auszug | Stichwortverzeichnis
Tags, die Kunden mit diesem Produkt verbinden(Was ist das?)Klicken Sie zum Suchen verwandter Artikel, Diskussionen oder Personen auf ein Tag.
|
Eine digitale Version dieses Buchs im Kindle-Shop verkaufen
Wenn Sie ein Verleger oder Autor sind und die digitalen Rechte an einem Buch haben, können Sie die digitale Version des Buchs in unserem Kindle-Shop verkaufen.
Weitere Informationen
Kundenrezensionen
Die hilfreichsten Kundenrezensionen
Format:Gebundene Ausgabe
The book covers an interesting subject - making your programs tolerant to faults, rather then trying to make them fault-free, which is nearly hopeless for non-trivial programs. It does so by introducing a number of related patterns, called a pattern language, which helps to detect, mitigate and ulimately fix errors. The patterns often reference each other, which can be a bit overwhelming at first. However, the book also provides graphs, which really helps to untangle the relationships.
The patterns are not presented in GoF Form, which in this case is actually a good thing because the patterns often try to make you aware of a certain problem, or propose a generic solution to a group of problems, rather than to explain a very narrow solution to a concrete problem. This, combined with the many relationships each pattern has, makes it rather hard to read just one pattern. I used the book during a course, where we had to read a number of patterns each week. I often couldn't help to read the whole chapter in advance, simply because the many related patterns were to good to pass up. This also means that you get a very good overview of the subject, if you complete the book.
The book also introduces a clear, stringent terminology and thus provides a common language, which came in very handy during discussions with other students.
The book is a very worthwhile read, just don't use it as a short reference guide, it's not meant to be that. All things considered, I really liked the book.
The patterns are not presented in GoF Form, which in this case is actually a good thing because the patterns often try to make you aware of a certain problem, or propose a generic solution to a group of problems, rather than to explain a very narrow solution to a concrete problem. This, combined with the many relationships each pattern has, makes it rather hard to read just one pattern. I used the book during a course, where we had to read a number of patterns each week. I often couldn't help to read the whole chapter in advance, simply because the many related patterns were to good to pass up. This also means that you get a very good overview of the subject, if you complete the book.
The book also introduces a clear, stringent terminology and thus provides a common language, which came in very handy during discussions with other students.
The book is a very worthwhile read, just don't use it as a short reference guide, it's not meant to be that. All things considered, I really liked the book.
Die hilfreichsten Kundenrezensionen auf Amazon.com (beta)
Amazon.com:
2 Rezensionen
13 von 13 Kunden fanden die folgende Rezension hilfreich
Good as introductory material though still immature
19. Februar 2008
Format:Gebundene Ausgabe
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.
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 von 6 Kunden fanden die folgende Rezension hilfreich
Well written Patterns about a interesting domain
22. Dezember 2009
Format:Gebundene Ausgabe
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.
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.
Waren diese Rezensionen hilfreich?
Wir wollen von Ihnen hören.
Kunden diskutieren
|
Das Forum zu diesem Produkt
Fragen stellen, Meinungen austauschen, Einblicke gewinnen Aktive Diskussionen in ähnlichen Foren
Kundendiskussionen durchsuchen
|
Ähnliche Foren
|
||||||||||||||||||||||||||||||||||
Lieblingslisten
Ähnliche Artikel finden
Anhand des Sachgebietes nach ähnlichen Produkten suchen:
Ihr Kommentar
Möchten Sie die Produktinformationen aktualisieren oder Feedback zu den Produktabbildungen geben?
|
