1st Edition

Fundamentals of Dependable Computing for Software Engineers

By John Knight Copyright 2012
    440 Pages 104 B/W Illustrations
    by Chapman & Hall

    433 Pages
    by Chapman & Hall

    Fundamentals of Dependable Computing for Software Engineers presents the essential elements of computer system dependability. The book describes a comprehensive dependability-engineering process and explains the roles of software and software engineers in computer system dependability.

    Readers will learn:

    • Why dependability matters
    • What it means for a system to be dependable
    • How to build a dependable software system
    • How to assess whether a software system is adequately dependable

    The author focuses on the actions needed to reduce the rate of failure to an acceptable level, covering material essential for engineers developing systems with extreme consequences of failure, such as safety-critical systems, security-critical systems, and critical infrastructure systems. The text explores the systems engineering aspects of dependability and provides a framework for engineers to reason and make decisions about software and its dependability. It also offers a comprehensive approach to achieve software dependability and includes a bibliography of the most relevant literature.

    Emphasizing the software engineering elements of dependability, this book helps software and computer engineers in fields requiring ultra-high levels of dependability, such as avionics, medical devices, automotive electronics, weapon systems, and advanced information systems, construct software systems that are dependable and within budget and time constraints.

    The Elements of Dependability
    The Role of the Software Engineer
    Our Dependence on Computers
    Some Regrettable Failures
    Consequences of Failure
    The Need for Dependability
    Systems and Their Dependability Requirements
    Where Do We Go from Here?
    Organization of This Book

    Dependability Requirements
    Why We Need Dependability Requirements
    The Evolution of Dependability Concepts
    The Role of Terminology
    What Is a System?
    Requirements and Specification
    Dependability and Its Attributes
    Systems, Software and Dependability
    Defining Dependability Requirements
    As Low as Is Reasonably Practicable (ALARP)

    Errors, Faults, and Hazards
    The Complexity of Erroneous States
    Faults and Dependability
    The Manifestation of Faults
    Degradation Faults
    Design Faults
    Byzantine Faults
    Component Failure Semantics
    Fundamental Principle of Dependability
    Anticipated Faults
    Engineering Dependable Systems

    Dependability Analysis
    Anticipating Faults
    Generalizing the Notion of Hazard
    Fault Tree Analysis
    Failure Modes, Effects and Criticality Analysis
    Hazard and Operability Analysis

    Dealing with Faults
    Faults and Their Treatment
    Fault Avoidance
    Fault Elimination
    Fault Tolerance
    Fault Forecasting
    Applying the Four Approaches to Fault Treatment
    Dealing with Byzantine Faults

    Degradation Faults and Software
    Impact on Software
    Redundant Architectures
    Quantifying the Benefits of Redundancy
    Distributed Systems and Fail Stop Computers

    Software Dependability
    Faults and the Software Lifecycle
    Formal Techniques
    Verification by Model Checking
    Correctness by Construction
    Approaches to Correctness by Construction
    Correctness by Construction — Synthesis
    Correctness by Construction — Refinement
    Software Fault Avoidance
    Software Fault Elimination
    Managing Software Fault Avoidance and Elimination
    Misconceptions about Software Dependability

    Software Fault Avoidance in Specification
    The Role of Specification
    Difficulties with Natural Languages
    Specification Difficulties
    Formal Languages
    Model-Based Specification
    The Declarative Language Z
    A Simple Example
    A Detailed Example
    Overview of Formal Specification Development

    Software Fault Avoidance in Implementation
    Implementing Software
    Programming Languages
    An Overview of Ada
    Programming Standards
    Correctness by Construction — SPARK

    Software Fault Elimination
    Why Fault Elimination?

    Software Fault Tolerance
    Components Subject to Design Faults
    Issues with Design Fault Tolerance
    Software Replication
    Design Diversity
    Data Diversity
    Targeted Fault Tolerance

    Dependability Assessment
    Approaches to Assessment
    Quantitative Assessment
    Prescriptive Standards
    Rigorous Arguments
    Applicability of Argumentation


    Exercises appear at the end of each chapter.


    John Knight is a professor of computer science at the University of Virginia. Prior to joining the University of Virginia, he was with NASA’s Langley Research Center. Dr. Knight has been a recipient of the Harlan D. Mills award from the IEEE Computer Society and the Distinguished Service award from ACM’s Special Interest Group on Software Engineering (SIGSOFT). He is an editorial board member of the Empirical Software Engineering Journal and was editor of the IEEE Transactions on Software Engineering from January 2002 to December 2005.

    The book is an important addition to one’s bookshelf. … it is insightful, close to faultless, and a wonderful reference. Read it from front to back and cite it in your proposals and professional and scholarly papers. … This book can and should be taught as part of an undergraduate or graduate software engineering program. I wish it had been available when I was setting up a graduate software engineering program … .
    —Larry Bernstein, Computing Reviews, June 2012

    This book takes full advantage of the extensive work that has been undertaken over many years on the creation of a rich set of system dependability concepts. John Knight makes excellent use of these concepts in producing a very well-argued and comprehensive account, aimed squarely at software engineers, of the variety of dependability issues they are likely to find in real systems and of the strategies that they should use to address these issues. Appropriately qualified students who study this book thoroughly and computer professionals seeking a greater understanding of the various dependability-related problems that they have encountered already in their careers should gain much from this book. I therefore take great pleasure in enthusiastically recommending it to both classes of reader.
    —From the Foreword by Brian Randell, Newcastle University, UK