High-Integrity System Specification and Design

From the Publisher: This volume provides the reader with a comprehensive introduction to system specification and design methods, with particular emphasis on structured and formal methods, method integration, concurrency and safety-critical systems. It contains both new material by Jonathan Bowen and Michael Hinchey, along with reprints of classic articles on high-integrity systems which have never before appeared together in a single volume.

[1]  C. A. R. Hoare,et al.  The logic of engineering design , 1996, Microprocessing and Microprogramming.

[2]  Jonathan P. Bowen,et al.  Safety-critical systems, formal methods and standards , 1993, Softw. Eng. J..

[3]  Norbert E. Fuchs.  Specifications are (preferably) executable , 1992, Softw. Eng. J..

[4]  John A. McDermid,et al.  Formal Methods: Use and Relevance for the Development of Safety-Critical Systems , 1992, Comput. J..

[5]  Edward Yourdon,et al.  Object-oriented design , 1991, Yourdon Press Computing Series.

[6]  Anders P. Ravn,et al.  Developing Correct Systems , 1993, Fifth Euromicro Workshop on Real-Time Systems.

[7]  Peter T. Breuer,et al.  Formal specifications in software maintenance: from code to Z++ and back again , 1993, Inf. Softw. Technol..

[8]  Anthony Hall.  Using Formal Methods to Develop an ATC Information System , 1996, IEEE Softw..

[9]  Stephen J. Garland,et al.  Larch: Languages and Tools for Formal Specification , 1993, Texts and Monographs in Computer Science.

[10]  Jonathan P. Bowen.  The ethics of safety-critical systems , 2000, CACM.

[11]  Richard Marlon Stein.  Real-time multicomputer software systems , 1992 .

[12]  Grady Booch,et al.  Object-oriented analysis and design with applications (2nd ed.) , 1993 .

[13]  Ben L. Di Vito,et al.  Formalizing space shuttle software requirements: four case studies , 1998, TSEM.

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

[15]  Jonathan P. Bowen.  Towards Verified Systems , 1994 .

[16]  Kevin Lano,et al.  Formalising the UML in Structured Temporal Theories , 1999, Behavioral Specifications of Businesses and Systems.

[17]  Sape Mullender,et al.  Distributed systems , 1989 .

[18]  C. A. R. Hoare,et al.  Algebra and models , 1993, SIGSOFT '93.

[19]  Jonathan P. Bowen,et al.  Ten Commandments of Formal Methods , 1995, Computer.

[20]  Bev Littlewood,et al.  THE RISKS OF SOFTWARE , 1992 .

[21]  Gerard J. Holzmann,et al.  Formal Methods for Early Fault Detection , 1996, FTRTFT.

[22]  Leonard L. Tripp,et al.  Guide to Software Engineering Standards and Specifications , 1997 .

[23]  Leslie Lamport,et al.  Time, clocks, and the ordering of events in a distributed system , 1978, CACM.

[24]  Sten Agerholm,et al.  Proof in VDM: Case Studies , 1998, Formal Approaches to Computing and Information Technology (FACIT).

[25]  Kuldeep Kumar,et al.  Strategies for incorporating formal specifications in software development , 1994, CACM.

[26]  Christine Draper,et al.  Practical Experiences of Z and SSADM , 1992, Z User Workshop.

[27]  W. J. Kubitz,et al.  Biting the silver bullet: toward a brighter future for system development , 1992 .

[28]  Barry W. Boehm,et al.  Software Engineering Economics , 1993, IEEE Transactions on Software Engineering.

[29]  Leslie Lamport,et al.  LATEX. A document preparation system. User's Guide and Reference Manual , 1996 .

[30]  David Harel,et al.  On visual formalisms , 1988, CACM.

[31]  Carroll Morgan,et al.  Programming from specifications (2nd ed.) , 1994 .

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

[33]  Gerard J. Holzmann,et al.  The Model Checker SPIN , 1997, IEEE Trans. Software Eng..

[34]  David Garlan,et al.  Making formal methods education effective for professional software engineers , 1995, Inf. Softw. Technol..

[35]  Philippe A. Palanque,et al.  Formal Methods in Human-Computer Interaction , 1997, Formal Approaches to Computing and Information Technology (FACIT).

[36]  Jeannette M. Wing,et al.  Specification matching of software components , 1997 .

[37]  Bev Littlewood,et al.  Guest Editors' Introduction: Critical Task of Writing Dependable Software , 1994, IEEE Softw..

[38]  Barry Eaglestone,et al.  Software development: two approaches to animation of Z specifications using Prolog , 1992, Softw. Eng. J..

[39]  Jonathan P. Bowen.  Formal Specification and Documentation Using Z: A Case Study Approach , 1996 .

[40]  Ivar Jacobson,et al.  The Unified Modeling Language User Guide , 1998, J. Database Manag..

[41]  Michael W. Godfrey,et al.  Formal Specification in Metamorphic Programing , 1991, VDM Europe.

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

[43]  Klaus Grimm.  Industrial Requirements for the Efficient Development of Reliable Embedded Systems , 1998, ZUM.

[44]  Jean-Raymond Abrial,et al.  The B-book - assigning programs to meanings , 1996 .

[45]  Jonathan Jacky,et al.  Specifying a Safety-Critical Control System in Z , 1993, IEEE Trans. Software Eng..

[46]  Felix Redmill,et al.  Safety-critical Systems: Current issues, techniques and standards , 1993 .

[47]  Paul Ward,et al.  Structured Development for Real-Time Systems , 1986 .

[48]  Jeannette M. Wing.  A specifier's introduction to formal methods , 1990, Computer.

[49]  David Lorge Parnas.  Teaching Programming as Engineering , 1995, ZUM.

[50]  Martín Abadi,et al.  Composing specifications , 1989, TOPL.

[51]  Jonathan P. Bowen,et al.  Personal view: Formal methods: epideictic or apodeictic? , 1994 .

[52]  Egon Börger,et al.  Formal Methods for Industrial Applications , 1996, Lecture Notes in Computer Science.

[53]  John Rushby,et al.  Formal Methods and their Role in the Certification of Critical Systems , 1997 .

[54]  Nancy Leveson,et al.  An assessment of space shuttle flight software development processes , 1993 .

[55]  Jonathan P. Bowen,et al.  Applications of Formal Methods , 1995 .

[56]  C. A. R. Hoare,et al.  An Overview of Some Formal Methods for Program Design , 1987, Computer.

[57]  Jim Gray,et al.  An approach to decentralized computer systems , 1986, IEEE Transactions on Software Engineering.

[58]  C. A. R. Hoare,et al.  Communicating Sequential Processes (Reprint) , 1983, Commun. ACM.

[59]  Neil R. Storey,et al.  Safety-critical computer systems , 1996 .

[60]  Gregory R. Andrews,et al.  Concepts and Notations for Concurrent Programming , 1983, CSUR.

[61]  Edward Yourdon,et al.  Case studies in object-oriented analysis and design , 1975 .

[62]  Louise E. Moser,et al.  A graphical environment for the design of concurrent real-time systems , 1997, TSEM.

[63]  Jonathan P. Bowen,et al.  ZUM '97: The Z Formal Specification Notation , 1997, Lecture Notes in Computer Science.

[64]  Kenneth J. Turner,et al.  Using Formal Description Techniques: An Introduction to Estelle, Lotos, and SDL , 1993 .

[65]  Michael Harrison.  Engineering Human-Error Tolerant Software , 1991, Z User Workshop.

[66]  John Cooke.  Constructing correct software - the basics , 1998, FACIT: Formal approaches to computing and information technology.

[67]  Stephen A. Jarvis,et al.  Concurrent systems - formal development in CSP , 1995, McGrawhill international series in software engineering.

[68]  Jonathan P. Bowen,et al.  Formal Models and the Specification Process , 1997, The Computer Science and Engineering Handbook.

[69]  C. A. R. Hoare,et al.  How Did Software Get So Reliable Without Proof? , 1996, FME.

[70]  Tom DeMarco,et al.  Structured Analysis and System Specification , 1978 .

[71]  Ernst-Rüdiger Olderog,et al.  A ProCoS II Project Final Report: ESPRIT Basic Research project 7071 , 1996 .

[72]  Andrew William Roscoe,et al.  The Theory and Practice of Concurrency , 1997 .

[73]  Leslie Hatton.  Safer C: Developing for High-Integrity and Safety-Critical Systems , 1995 .

[74]  D.R. Wallace,et al.  An analysis of selected software safety standards , 1992, IEEE Aerospace and Electronic Systems Magazine.

[75]  D. L. Parnas,et al.  On the criteria to be used in decomposing systems into modules , 1972, Software Pioneers.

[76]  Alastair R. Ruddle.  Formal Methods in the Specification of Real-Time, Safety-Critical Control Systems , 1992, Z User Workshop.

[77]  Richard Marlon Stein.  Safety by formal design , 1992 .

[78]  Jim Woodcock,et al.  FME '93: Industrial-Strength Formal Methods , 1993, Lecture Notes in Computer Science.

[79]  G. O'Neill.  Automatic Translation of VDM Specifications into Standard ML Programs (Short Note) , 1992, Comput. J..

[80]  Hans-Erik Eriksson,et al.  UML toolkit , 1997 .

[81]  Gérard Le Lann,et al.  Motivations, Objectives and Characterization of Distributed Systems , 1980, Advanced Course: Distributed Systems.

[82]  G. R. Gladden.  Stop the life-cycle, I want to get off , 1982, ACM SIGSOFT Softw. Eng. Notes.

[83]  Jim Woodcock,et al.  Using Z - specification, refinement, and proof , 1996, Prentice Hall international series in computer science.

[84]  Rance Cleaveland,et al.  Strategic directions in concurrency research , 1996, CSUR.

[85]  Harlan D. Mills,et al.  Zero Defect Software: Cleanroom Engineering , 1993, Adv. Comput..

[86]  David Lorge Parnas,et al.  An Invitation to Formal Methods , 1996, Computer.

[87]  Matthias Weber,et al.  Object-Oriented Specification of Hybrid Systems Using UMLh and ZimOO , 1998, ZUM.

[88]  Dan Craigen,et al.  Case study: Darlington nuclear generating station [software-driven shutdown systems] , 1994, IEEE Software.

[89]  Martyn Thomas.  The industrial use of formal methods , 1993, Microprocess. Microsystems.

[90]  Peter G. Neumann,et al.  Computer-related risks , 1994 .

[91]  Michael Jackson,et al.  Four dark corners of requirements engineering , 1997, TSEM.

[92]  Leslie Hatton,et al.  Software failures-follies and fallacies , 1997 .

[93]  Didier Bert.  B’98: Recent Advances in the Development and Use of the B Method , 1998, Lecture Notes in Computer Science.

[94]  Jeremy Dick,et al.  Lessons learned from rigorous system software development , 1997, Inf. Softw. Technol..

[95]  John J. Marciniak,et al.  Encyclopedia of Software Engineering , 1994, Encyclopedia of Software Engineering.

[96]  Jonathan P. Bowen,et al.  Seven More Myths of Formal Methods , 1995, IEEE Softw..

[97]  S. Aujla,et al.  A rigorous review technique: using formal notations within conventional development methods , 1993, Proceedings 1993 Software Engineering Standards Symposium.

[98]  Jonathan P. Bowen,et al.  The Industrial Take-up of Formal Methods in Safety-Critical and Other Areas: A Perspective , 1993, FME.

[99]  John Barnes,et al.  High Integrity Ada: The Spark Approach , 1997 .

[100]  Vijay K. Vaishnavi,et al.  A formal specifications maturity model , 1997, CACM.

[101]  Elliot J. Chikofsky,et al.  CASE: reliability engineering for information systems , 1988, IEEE Software.

[102]  Robert Balzer,et al.  On the inevitable intertwining of specification and implementation , 1982, CACM.

[103]  Hassan Gomaa.  Software design methods for concurrent and real-time systems , 1993, SEI series in software engineering.

[104]  J. P. Potocki de Montalk.  Computer software in civil aircraft , 1993, Microprocess. Microsystems.

[105]  David Lorge Parnas,et al.  Education for computing professionals , 1990, Computer.

[106]  Peter T. Breuer,et al.  Towards Correct Executable Semantics for Z , 1994, Z User Workshop.

[107]  David Harel,et al.  Statecharts: A Visual Formalism for Complex Systems , 1987, Sci. Comput. Program..

[108]  Amnon Naamad,et al.  The STATEMATE semantics of statecharts , 1996, TSEM.

[109]  C. Neville Dean,et al.  Teaching and learning formal methods , 1996 .

[110]  Barrie Sherman,et al.  Licensed to work , 1995 .

[111]  Grady Booch,et al.  Object Solutions: Managing the Object-Oriented Project , 1995 .

[112]  Wolfgang A. Halang,et al.  Constructing Predictable Real Time Systems , 1991 .

[113]  Jonathan Jacky,et al.  The Way of Z: Practical Programming with Formal Methods , 1996 .

[114]  Susan Stepney,et al.  High integrity compilation - a case study , 1993 .

[115]  Dan Craigen,et al.  Experience with formal methods in critical systems , 1994, IEEE Software.

[116]  John R. Cameron,et al.  An overview of JSD , 1986, IEEE Transactions on Software Engineering.

[117]  Jeremy L. Jacob,et al.  A practical language and toolkit for high-integrity tools , 1998, J. Syst. Softw..

[118]  Robert B. France,et al.  Integrated Structured Analysis and Formal Specification Techniques , 1992, Comput. J..

[119]  Edmund M. Clarke,et al.  Formal Methods: State of the Art and Future Directions Working Group Members , 1996 .

[120]  Jonathan P. Bowen,et al.  ZUM '98: The Z Formal Specification Notation , 1998 .

[121]  Dimitris Gritzalis,et al.  Reliability, Quality and Safety of Software-Intensive Systems , 1997, IFIP — The International Federation for Information Processing.

[122]  Harlan D. Mills,et al.  Cleanroom Software Engineering , 1987, IEEE Software.

[123]  Grady Booch,et al.  Object-oriented development , 1986, IEEE Transactions on Software Engineering.

[124]  Eerke A. Boiten,et al.  How to Produce Correct Software - An Introduction to Formal Specification and Program Development by Transformations , 1992, Comput. J..

[125]  Dietmar Reinert,et al.  Risk and system integrity concepts for safety-related control systems , 1993, Microprocess. Microsystems.

[126]  David Lorge Parnas,et al.  Successful software engineering research , 1998, SOEN.

[127]  Roger M. Needham,et al.  Cryptography and secure channels , 1993 .

[128]  Grady Booch,et al.  Object-Oriented Analysis and Design with Applications , 1990 .

[129]  Bertrand Meyer,et al.  On Formalism in Specifications , 1985, IEEE Software.

[130]  Peter Gorm Larsen,et al.  Applying Formal Specification in Industry , 1996, IEEE Softw..

[131]  David Lorge Parnas,et al.  "Formal methods" technology transfer will fail , 1998, J. Syst. Softw..

[132]  Stefania Gnesi,et al.  A Formal Verification Environment for Railway Signaling System Design , 1998, Formal Methods Syst. Des..

[133]  Roger S. Pressman,et al.  Software Engineering: A Practitioner's Approach , 1982 .

[134]  C. A. R. Hoare,et al.  A Theory of Communicating Sequential Processes , 1984, JACM.

[135]  Sérgio Vale Aguiar Campos,et al.  Symbolic Model Checking , 1993, CAV.

[136]  J. Doug Tygar,et al.  Miró: Visual Specification of Security , 1990, IEEE Trans. Software Eng..

[137]  Natarajan Shankar,et al.  PVS: A Prototype Verification System , 1992, CADE.

[138]  Jifeng He.  Provably Correct Systems: Modelling of Communication Languages and Design of Optimized Compilers , 1994 .

[139]  Glenford J. Myers,et al.  Structured Design , 1999, IBM Syst. J..

[140]  W. Wayt Gibbs,et al.  Software's Chronic Crisis , 1994 .

[141]  Cliff B. Jones,et al.  Specifications are not (necessarily) executable , 1989 .

[142]  David Lorge Parnas,et al.  Predicate Logic for Software Engineering , 1993, IEEE Trans. Software Eng..

[143]  Robert L. Grossman,et al.  Timed Automata , 1999, CAV.

[144]  Pete Sawyer,et al.  Requirements Engineering: A Good Practice Guide , 1997 .

[145]  Jonathan P. Bowen.  Formal methods in safety-critical standards , 1993, Proceedings 1993 Software Engineering Standards Symposium.

[146]  Darrel C. Ince.  Arrays and pointers considered harmful , 1992, SIGP.

[147]  David Lorge Parnas,et al.  Assessment of safety-critical software in nuclear power plants , 1991 .

[148]  Nancy G. Leveson,et al.  An investigation of the Therac-25 accidents , 1993, Computer.

[149]  Richard A. Kemmerer,et al.  Integrating formal methods into the development process , 1990, IEEE Software.

[150]  Michael Purdue,et al.  Sizewell B: An Anatomy of the Inquiry , 1988 .

[151]  Hossein Saiedian,et al.  Challenges in the successful transfer of formal methods technology into industrial applications , 1996, Inf. Softw. Technol..

[152]  Nimal Nissanke.  Realtime systems , 1997, Prentice Hall series in computer science.

[153]  Nancy G. Leveson,et al.  Software safety in embedded computer systems , 1991, CACM.

[154]  Donald MacKenzie,et al.  The automation of proof: a historical and sociological exploration , 1995, IEEE Ann. Hist. Comput..

[155]  Daniel D. McCracken,et al.  Life cycle concept considered harmful , 1982, ACM SIGSOFT Softw. Eng. Notes.

[156]  Luqi,et al.  Formal Methods: Promises And Problems , 1997, IEEE Softw..

[157]  Kevin Lano.  The B language and method - a guide to practical formal development , 1996, FACIT: Formal approaches to computing and information technology.

[158]  Kevin Lano,et al.  Formal object-oriented development , 1995, FACIT: Formal approaches to computing and information technology.

[159]  Mike Hinchey.  The design of real-time applications , 1993, [1993] Proceedings of the IEEE Workshop on Real-Time Applications.

[160]  Jonathan S. Ostroff,et al.  Formal methods for the specification and design of real-time safety critical systems , 1992, J. Syst. Softw..

[161]  C. Gaskell,et al.  Professional issues in software engineering: the perspective of UK academics , 1996 .

[162]  John Herbert,et al.  Towards Verified Systems: The SAFEMOS Project , 1995 .

[163]  Jim Woodcock,et al.  The Formal Specification in Z of Defence Standard 00-56 , 1994, Z User Workshop.

[164]  Kaisa Sere,et al.  Program Development by Refinement: Case Studies Using The B Method , 1998 .

[165]  David Lorge Parnas,et al.  Software engineering: an unconsummated marriage , 1997, CACM.

[166]  John A. McDermid,et al.  Safety Case Development: Current Practice, Future Prospects , 1997 .

[167]  Pamela Zave,et al.  An Operational Approach to Requirements Specification for Embedded Systems , 1982, IEEE Transactions on Software Engineering.

[168]  Edward Yourdon,et al.  Modern structured analysis , 1989 .

[169]  Leslie Lamport,et al.  The temporal logic of actions , 1994, TOPL.

[170]  Michael Dyer.  The Cleanroom Approach to Quality Software Development , 1992, Int. CMG Conference.

[171]  John C. Knight,et al.  Preliminary Experience Using Z to Specify a Safety-Critical System , 1992, Z User Workshop.

[172]  Michael Jackson,et al.  Principles of program design , 1975 .

[173]  David Lorge Parnas,et al.  Precise description and specification of software , 1998 .

[174]  Constance L. Heitmeyer,et al.  Formal Methods: A Panacea or Academic Poppycock? , 1997, ZUM.

[175]  Jonathan P. Bowen,et al.  Distributed operating systems , 1990 .

[176]  J. A. Goguen.  More thoughts on specification and verification , 1981, SOEN.

[177]  Stuart R. Faulk,et al.  Software Requirements: A Tutorial, , 1995 .

[178]  Pierre Flener,et al.  Specifications are necessarily informal or: Some more myths of formal methods , 1998, J. Syst. Softw..

[179]  Roger M. Needham,et al.  On the duality of operating system structures , 1979, OPSR.

[180]  Ricky W. Butler,et al.  The infeasibility of experimental quantification of life-critical software reliability , 1991 .

[181]  Ivar Jacobson,et al.  The unified modeling language reference manual , 2010 .

[182]  Robert S. Boyer,et al.  A computational logic handbook , 1979, Perspectives in computing.

[183]  Dino Mandrioli,et al.  Formal Methods for Real-Time Computing , 1996 .

[184]  Mathai Joseph,et al.  Real-time systems - specification, verification and analysis , 1995, Prentice Hall International series in computer science.

[185]  Gregory D. Abowd,et al.  Human-computer interaction (2nd ed.) , 1998 .

[186]  W. W. Royce,et al.  Managing the development of large software systems , 1970 .

[187]  Fred B. Schneider,et al.  A Logical Approach to Discrete Math , 1993, Texts and Monographs in Computer Science.

[188]  Tim Berners-Lee,et al.  WWW: Past, Present, and Future , 1996, Computer.

[189]  John E. Nicholls.  A Survey of Z Courses in the UK , 1990, Z User Workshop.

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

[191]  Steve Easterbrook,et al.  Formal methods for verification and validation of partial specifications: A case study , 1998, J. Syst. Softw..

[192]  Jr. Allen B. Tucker,et al.  The Computer Science and Engineering Handbook , 1997 .

[193]  M. Elizabeth C. Hull,et al.  Object-oriented design, Jackson system development (JSD) specifications and concurrency , 1989, Softw. Eng. J..

[194]  Leslie Lamport,et al.  Artificial Intelligence and Language Processing ]acques Cohen Editor a Simple Approach to Specifying Concurrent Systems , 2022 .

[195]  Robin Milner,et al.  Communication and concurrency , 1989, PHI Series in computer science.

[196]  Anthony Hall,et al.  Seven myths of formal methods , 1990, IEEE Software.

[197]  Andrew S. Tanenbaum,et al.  A Critique of the Remote Procedure Call Paradigm , 1988 .