Engineering modeling and analysis: sound methods and effective tools

Developing high quality software tools for specialized domains is difficult. One problem is the cost of developing feature-rich and usable tool interfaces. Another problem is the task of providing a sound basis for trustworthiness of the tool and the overall method which it supports. In this dissertation we present and evaluate an approach which addresses these key difficulties. The approach is based on two concepts: using specialized and tightly integrated mass-market applications to provide the bulk of the tool’s functionality, and the use of formal methods for the precise specification of the tool’s domain-dependent modeling language. We have evaluated our component-based work in part by developing a tool using the technique, deploying it to NASA, and having engineers from across the organization use and evaluate it. In the area of formal methods, we have developed and validated, both informally and formally, a mathematically precise specification of the language employed by an innovative modeling and analysis method for the reliability of fault tolerant systems. We have also developed a prototype tool that shows in concrete terms that our combined approach can work. The chief contribution of this work is a new approach to developing software tools having formal foundations for trustworthiness and sophisticated user interfaces. Constituent contributions include a qualified positive evaluation of the component-based approach, a proof of feasibility of using formal methods for domain-specific modeling languages, and the precise definition of an important modeling language, namely one for dynamic fault tree analysis.

[1]  Robert Balzer,et al.  The ISI visual design editor generator , 1999, Proceedings 1999 IEEE Symposium on Visual Languages.

[2]  David Coppit,et al.  Formal semantics of models for computational engineering: a case study on dynamic fault trees , 2000, Proceedings 11th International Symposium on Software Reliability Engineering. ISSRE 2000.

[3]  Mary Shaw,et al.  Innovation and Obstacles: the Future of Computing , 1998, Computer.

[4]  G. Fox,et al.  A software development process for COTS-based information system infrastructure , 1997, Proceedings Fifth International Symposium on Assessment of Software Tools and Technologies.

[5]  Gregory D. Abowd,et al.  Formalizing style to understand descriptions of software architecture , 1995, TSEM.

[6]  J. B. Dugan,et al.  A benchmark for quantitative fault tree reliability analysis , 2001, Annual Reliability and Maintainability Symposium. 2001 Proceedings. International Symposium on Product Quality and Integrity (Cat. No.01CH37179).

[7]  Joanne Bechta Dugan,et al.  DIFtree: a software package for the analysis of dynamic fault tree models , 1997, Annual Reliability and Maintainability Symposium.

[8]  W E Vesely,et al.  Fault Tree Handbook , 1987 .

[9]  Kevin J. Sullivan,et al.  Analysis of a Conflict between Aggregation and Interface Negotiation in Microsoft's Component Object Model , 1999, IEEE Trans. Software Eng..

[10]  David Garlan,et al.  Architectural Mismatch: Why Reuse Is So Hard , 1995, IEEE Softw..

[11]  David A Chappell Understanding ActiveX and OLE , 1996 .

[12]  J. M. Neighbors,et al.  Draco: a method for engineering reusable software systems , 1989 .

[13]  David Coppit,et al.  Package-oriented programming of engineering tools , 1997, ICSE '97.

[14]  Mary Shaw,et al.  Architectural issues in software reuse: it's not just the functionality, it's the packaging , 1995, SSR '95.

[15]  Mehdi Jazayeri,et al.  Component Programming - a Fresh Look at Software Components , 1995, ESEC.

[16]  Gabor Karsai,et al.  The Generic Modeling Environment , 2001 .

[17]  Olivier Coudert,et al.  Fault tree analysis: 10/sup 20/ prime implicants and beyond , 1993, Annual Reliability and Maintainability Symposium 1993 Proceedings.

[18]  David Coppit,et al.  Formal specification in collaborative design of critical software tools , 1998, Proceedings Third IEEE International High-Assurance Systems Engineering Symposium (Cat. No.98EX231).

[19]  John C. Knight,et al.  Why are Formal Methods Not Used More Widely , 1997 .

[20]  Mark Allen Boyd Dynamic fault tree models: techniques for analysis of advanced fault tolerant computer systems , 1992 .

[21]  Bernhard Rumpe,et al.  The UML as a formal modeling notation , 1998, Comput. Stand. Interfaces.

[22]  Arun K. Somani,et al.  Hierarchical analysis of fault trees with dependencies, using decomposition , 1998, Annual Reliability and Maintainability Symposium. 1998 Proceedings. International Symposium on Product Quality and Integrity.

[23]  Kevin J. Sullivan,et al.  Exploration harnesses: tool-supported interactive discovery of commercial component properties , 1999, 14th IEEE International Conference on Automated Software Engineering.

[24]  Samuel N. Kamin,et al.  A Special-Purpose Language for Picture-Drawing , 1997, DSL.

[25]  J. Dugan,et al.  A modular approach for analyzing static and dynamic fault trees , 1997, Annual Reliability and Maintainability Symposium.

[26]  하수철,et al.  [서평]「Component Software」 - Beyond Object-Oriented Programming - , 2000 .

[27]  John C. Grundy,et al.  Constructing component-based software engineering environments: issues and experiences , 2000, Inf. Softw. Technol..

[28]  David R. Musser,et al.  STL tutorial and reference guide - C++ programming with the standard template library , 1996, Addison-Wesley professional computing series.

[29]  Salvatore J. Bavuso,et al.  Dynamic fault-tree models for fault-tolerant computer systems , 1992 .

[30]  Lisa Brownsword,et al.  The Opportunities and Complexities of Applying Commercial-Off-the-Shelf Components , 1998 .

[31]  Dale Rogerson,et al.  Inside COM , 1997 .

[32]  Kishor S. Trivedi,et al.  The hybrid automated reliability predictor , 1986 .

[33]  J. Michael Spivey,et al.  The Z notation - a reference manual , 1992, Prentice Hall International Series in Computer Science.

[34]  David Garlan,et al.  A formal basis for architectural connection , 1997, TSEM.

[35]  Eric Liu,et al.  Package-oriented software engineering: a generic architecture , 2001 .

[36]  J. Bechta Dugan,et al.  Bridging the gap between systems and dynamic fault tree models , 1999, Annual Reliability and Maintainability. Symposium. 1999 Proceedings (Cat. No.99CH36283).

[37]  Andy Roberts,et al.  How Accurate Is Scientific Software? , 1994, IEEE Trans. Software Eng..

[38]  John C. Knight,et al.  Safety critical systems: challenges and directions , 2002, Proceedings of the 24th International Conference on Software Engineering. ICSE 2002.

[39]  G. B. Finelli,et al.  The Infeasibility of Quantifying the Reliability of Life-Critical Real-Time Software , 1993, IEEE Trans. Software Eng..

[40]  Axel van Lamsweerde,et al.  Formal specification: a roadmap , 2000, ICSE '00.

[41]  Richard M. Adler,et al.  Emerging Standards for Component Software , 1995, Computer.

[42]  Gabor Karsai,et al.  Composing Domain-Specific Design Environments , 2001, Computer.

[43]  David Coppit,et al.  Multiple mass-market applications as components , 2000, Proceedings of the 2000 International Conference on Software Engineering. ICSE 2000 the New Millennium.

[44]  Suprasad V. Amari,et al.  A separable method for incorporating imperfect fault-coverage into combinatorial models , 1999 .

[45]  Mark Saaltink,et al.  The Z/EVES System , 1997, ZUM.

[46]  David Coppit,et al.  The Galileo fault tree analysis tool , 1999, Digest of Papers. Twenty-Ninth Annual International Symposium on Fault-Tolerant Computing (Cat. No.99CB36352).

[47]  David Coppit,et al.  Developing a low-cost high-quality software tool for dynamic fault-tree analysis , 2000, IEEE Trans. Reliab..

[48]  Kevin Sullivan,et al.  Reconciling behavioral mismatch through component restriction , 1999 .

[49]  Kevin J. Sullivan,et al.  Experience assessing an architectural approach to large-scale systematic reuse , 1996, Proceedings of IEEE 18th International Conference on Software Engineering.

[50]  P. Kidwell,et al.  The mythical man-month: Essays on software engineering , 1996, IEEE Annals of the History of Computing.

[51]  K. Sullivan,et al.  Galileo: a tool built from mass-market applications , 2000, Proceedings of the 2000 International Conference on Software Engineering. ICSE 2000 the New Millennium.

[52]  Salvatore J. Bavuso,et al.  Fault trees and Markov models for reliability analysis of fault-tolerant digital systems , 1993 .

[53]  Frederick P. Brooks,et al.  No Silver Bullet: Essence and Accidents of Software Engineering , 1987 .

[54]  Andreas Rausch,et al.  Componentware - Methodology and Process , 1999 .

[55]  T. Biggerstaff,et al.  Reusability Framework, Assessment, and Directions , 1987, IEEE Software.