- Author:
- John Knight
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.
Cited By
- Habibullah K, Heyn H, Gay G, Horkoff J, Knauss E, Borg M, Knauss A, Sivencrona H and Li P (2024). Requirements and software engineering for automotive perception systems: an interview study, Requirements Engineering, 29:1, (25-48), Online publication date: 1-Mar-2024.
- shboul B and Petriu D Pattern-based transformation of SysML models into fault tree models Proceedings of the 29th Annual International Conference on Computer Science and Software Engineering, (214-223)
- Lutz J, Lutz N, Lutz R and Riley M Robustness and games against nature in molecular programming Proceedings of the 41st International Conference on Software Engineering: New Ideas and Emerging Results, (65-68)
- Agrawal A, Khoshmanesh S, Vierhauser M, Rahimi M, Cleland-Huang J and Lutz R Leveraging artifact trees to evolve and reuse safety cases Proceedings of the 41st International Conference on Software Engineering, (1222-1233)
Ellis S, Klinge T, Lathrop J, Lutz J, Lutz R, Miner A and Potter H (2019). Runtime Fault Detection in Programmed Molecular Systems, ACM Transactions on Software Engineering and Methodology, 28:2, (1-20), Online publication date: 30-Apr-2019.- Rahimi M, Xiong W, Cleland-Huang J and Lutz R Diagnosing assumption problems in safety-critical products Proceedings of the 32nd IEEE/ACM International Conference on Automated Software Engineering, (473-484)
- Missiroli M, Russo D and Ciancarini P Agile for millennials Proceedings of the 1st International Workshop on Software Engineering Curricula for Millennials, (47-53)
- Tun T, Lutz R, Nakayama B, Yu Y, Mathur D and Nuseibeh B The role of environmental assumptions in failures of DNA nanosystems Proceedings of the First International Workshop on Complex faUlts and Failures in LargE Software Systems, (27-33)
- Alzahrani N and Petriu D Modeling Fault Tolerance Tactics with Reusable Aspects Proceedings of the 11th International ACM SIGSOFT Conference on Quality of Software Architectures, (43-52)
- Ellis S, Henderson E, Klinge T, Lathrop J, Lutz J, Lutz R, Mathur D and Miner A Automated requirements analysis for a molecular watchdog timer Proceedings of the 29th ACM/IEEE International Conference on Automated Software Engineering, (767-778)
Index Terms
- Fundamentals of Dependable Computing for Software Engineers
Recommendations
Are software engineers true engineers?
Software engineering is an often used term to describe the activities, methods, and tools of large scale software development. There is an ongoing discussion whether Software Engineering can be considered as an engineering discipline. In many respects ...
Larry Bernstein
John Knight skillfully writes about how to make software systems more dependable. His goal in writing this book is clearly stated in the preface. The book successfully bridges the disciplines of systems engineering and software engineering. Too many systems engineering books ignore the software components vital to 21st-century systems. These software-based systems must go beyond feature engineering to make such systems dependable. Knight defines what this means and outlines the theory of dependability that every professional software engineer, computer science instructor, and serious system engineer needs to read and understand. The book is an important addition to one's bookshelf. It is not perfect, but 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. The book is primarily qualitative, with a few excursions into quantitative analysis. I particularly liked Knight's use of code snippets to illustrate key points. Problems and code snippets are provided at the end of each of the 12 chapters. I was disappointed not to find a pointer to problem solutions. I also disliked the amount of space devoted to the often-discredited N -version programming. Knight ignores Parnas' great insight that, with software components, N -versions are not independent even when written by isolated teams. Later in the book, in chapter 6, he seems to restrict N -version to hardware components, but then returns to N -version design in chapter 11. In the preface, the author explains the organization of the book, which is very helpful. Chapter 1 describes why dependability is important, with examples and the scope of the theory. Chapter 2 covers systems, requirements, and failures. Chapter 3 defines errors and faults, and offers a wonderful explanation of hazards. I question the bathtub curve in Figure 3.3 that is a model for analog systems. Digital systems and software have fault curves that start out like the generic bathtub curve and then approach a steady state failure rate. His explanation of Byzantine faults is excellent. Chapter 4, on dependability analysis, contains the best description of fault tree analysis that I have seen. Chapter 5 explains fault avoidance, removal, tolerance, and forecasting. Chapter 6 describes degradation faults and shifts attention in N -version design to hardware components, which is appropriate. Chapter 7 has a software focus with the introduction of models. Many software dependability misconceptions are identified. Chapter 8 provides a quick tour of software engineering with a dependability slant. It deals with the Z formal specification language and the implications of incorrect specifications. Chapter 9 deals with specific and important implementation issues with the use of pre- and post-conditions. An analysis of the problems common to C programs is in Section 9.2.1. Chapter 10 is unique in dealing with many aspects of eliminating software faults before system delivery. The importance of inspections and testing is highlighted. Chapter 11 focuses on process, data, and code fault tolerance. Chapter 12 provides insights from the field on how to access software dependability from many viewpoints. I wish the book had a more detailed discussion of how to compute software reliability and the importance of the reliability equation. The book has a solid bibliography-make sure you visit reference 132. 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 at the Stevens Institute of Technology, in Hoboken, NJ, in 2002. Online Computing Reviews Service
Access critical reviews of Computing literature here
Become a reviewer for Computing Reviews.