High Level System Design and Analysis Using Abstract State Machines

We provide an introduction to a practical method for rigorous system development which has been used successfully, under industrial constraints, for design and analysis of complex hardware/software systems. The method allows one to start system development with a trustworthy high level system specification and to link such a "ground model" in a well documented and inspectable way through intermediate design steps to its implementation. The method enhances traditional operational modelling and analysis techniques by incorporating the most general abstraction, decomposition and refinement mechanisms which have become available through Gurevich's Abstract State Machines. Through its versatility the ASM approach is non-monolithic and integratable at any development level into current design and analysis environments. We also collect experimental evidence for the ASM thesis, a generalization of Turing's thesis.

[1]  Jim Alves-Foss,et al.  Formal Syntax and Semantics of Java , 2002, Lecture Notes in Computer Science.

[2]  Samuel Eilenberg,et al.  Automata, languages, and machines. A , 1974, Pure and applied mathematics.

[3]  R. Abraham,et al.  EVALUATING GENERALIZED TABULAR EXPRESSIONS IN SOFTWARE DOCUMENTATION , 1997 .

[4]  Wolf Zimmermann,et al.  On the Construction of Correct Compiler Back-Ends: An ASM-Approach , 1997, J. Univers. Comput. Sci..

[5]  Niklaus Wirth,et al.  Program development by stepwise refinement , 1971, CACM.

[6]  Robert L. Nord,et al.  Software Architecture in Industrial Applications , 1995, 1995 17th International Conference on Software Engineering.

[7]  Luciano Lavagno,et al.  Models of computation for system design , 2000 .

[8]  Uwe Glässer,et al.  Abstract State Machine Semantics of SDL , 1997, J. Univers. Comput. Sci..

[9]  Saharon Shelah,et al.  Choiceless Polynomial Time , 1997, Ann. Pure Appl. Log..

[10]  Elvinia Riccobene,et al.  A formal specification of PARLOG , 1993 .

[11]  Egon Börger,et al.  CLAM specification for provably correct compilation of CLP( R ) programs , 1993, Specification and validation methods.

[12]  A. Turing.  On Computable Numbers, with an Application to the Entscheidungsproblem. , 1937 .

[13]  Egon Brger,et al.  Modelling and Analysis of Distributed and Reactive Systems using Evolving Algebras , 1995 .

[14]  David Lorge Parnas,et al.  Functional Documents for Computer Systems , 1995, Sci. Comput. Program..

[15]  Edsger W. Dijkstra,et al.  Structured programming , 1972, A.P.I.C. Studies in data processing.

[16]  Dirk Siefkes,et al.  Finite Automata, Their Algebras and Grammars , 1990 .

[17]  David Lorge Parnas,et al.  Information Distribution Aspects of Design Methodology , 1971, IFIP Congress.

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

[19]  Egon Börger,et al.  Occam: Specification and Compiler Correctness - Part I: The Primary Model , 1994, PROCOMET.

[20]  Egon Börger,et al.  A Mathematical Definition of Full Prolog , 1995, Sci. Comput. Program..

[21]  Egon Börger,et al.  A Programmer Friendly Modular Definition of the Semantics of Java , 1999, Formal Syntax and Semantics of Java.

[22]  K. Popper,et al.  Logik der Forschung , 1935 .

[23]  Don S. Batory,et al.  Scalable software libraries , 1993, SIGSOFT '93.

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

[25]  Flemming Nielson,et al.  Semantics with applications - a formal introduction , 1992, Wiley professional computing.

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

[27]  Ryszard Janicki,et al.  Towards a Formal Semantics of Parnas Tables , 1995, 1995 17th International Conference on Software Engineering.

[28]  Gerhard Schellhorn,et al.  Verifikation abstrakter Zustandsmaschinen , 1999 .

[29]  Egon Börger,et al.  Correctness of Compiling Occam to Transputer Code , 1996, Comput. J..

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

[31]  Elvinia Riccobene,et al.  Refining Abstract Machine Specifications of the Steam Boiler Control to Well Documented Executable Code , 1995, Formal Methods for Industrial Applications.

[32]  Keehang Kwon,et al.  A Structured Presentation of a Closure-Based Compilation Method for a Scoping Notion in Logic Programming , 1997, J. Univers. Comput. Sci..

[33]  Robert F. Stärk,et al.  The Theoretical Foundations of LPTP (A Logic Program Theorem Prover) , 1998, J. Log. Program..

[34]  Wolfgang Goerigk,et al.  Rigorous Compiler Implementation Correctness: How to Prove the Real Thing Correct , 1998, FM-Trends.

[35]  Yuri Gurevich,et al.  Evolving algebras 1993: Lipari guide , 1995, Specification and validation methods.

[36]  Egon Börger,et al.  Defining the Java Virtual Machine as Platform for Provably Correct Java Compilation , 1998, MFCS.

[37]  Yuri Gurevich,et al.  Evolving Algebras: an Attempt to Discover Semantics , 1993, Current Trends in Theoretical Computer Science.

[38]  Mario Rodríguez-Artalejo,et al.  A Model for Mathematical Analysis of Functional Logic Programs and Their Implementations , 1994, IFIP Congress.

[39]  Wolfram Schulte,et al.  Modular design for the Java virtual machine architecture , 2000 .

[40]  Mike Holcombe.  X-machines as a basis for dynamic system specification , 1988, Softw. Eng. J..

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

[42]  Christian Morgenstern,et al.  Why Use Evolving Algebras for Hardware and Software Engineering ? ? , 1995 .

[43]  Richard Banach,et al.  Retrenchment: An Engineering Variation on Refinement , 1998, B.

[44]  Nicholas Pippenger,et al.  Pure versus impure Lisp , 1997, TOPL.

[45]  Wolfgang Ahrendt,et al.  Reasoning about Abstract State Machines: The WAM Case Study , 1997, J. Univers. Comput. Sci..

[46]  V. Rich.  Personal communication , 1989, Nature.

[47]  Egon Börger,et al.  Abstract State Machines 1988-1998: Commented ASM Bibliography , 1998, Bull. EATCS.

[48]  K. Popper.  Logik der Forschung : zur erkenntnistheorie der modernen naturwissenschaft , 1936 .

[49]  Michael Marcotty,et al.  The World of Programming Languages , 1987, Springer Books on Professional Computing.

[50]  Egon Brger,et al.  Formal de nition of an abstract VHDL''''93 simulator by EA - machines , 1995 .

[51]  W. M. Wonham,et al.  The control of discrete event systems , 1989 .

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

[53]  Yuri Gurevich,et al.  Algorithms in the world of bounded resources , 1988 .

[54]  Egon Börger,et al.  The WAM - Definition and Compiler Correctness , 1995, Logic Programming: Formal Methods and Practical Applications.

[55]  Hans Langmaack,et al.  Compiler Correctness and Implementation Veri cation : The Veri x , 1996 .

[56]  Jack Dongarra,et al.  Pvm 3 user's guide and reference manual , 1993 .

[57]  Meine van der Meulen,et al.  Formal Methods in the Specification of the Emergency Closing System of the Eastern Scheldt Storm Surge Barrier , 1998, FM-Trends.

[58]  Egon Börger,et al.  Initialization problems for Java , 2000, Softw. Concepts Tools.

[59]  Mary Shaw,et al.  Formulations and Formalisms in Software Architecture , 1995, Computer Science Today.

[60]  Alfred Tarski,et al.  Der Wahrheitsbegriff in den formalisierten Sprachen , 1935 .

[61]  Niklaus Wirth,et al.  Algorithms & data structures , 1985 .

[62]  Alfonso Pierantonio,et al.  Formal aspects of and development environments for Montages , 1997 .

[63]  Armin B. Cremers,et al.  Formal Modeling of Virtual Machines , 1978, IEEE Transactions on Software Engineering.

[64]  Cornelia Pusch,et al.  Verification of Compiler Correctness for the WAM , 1996, TPHOLs.

[65]  Yuri Gurevichz.  Metaanite Model Theory , 1997 .

[66]  Don S. Batory,et al.  Creating reference architectures: an example from avionics , 1995, SSR '95.

[67]  Egon Börger,et al.  The bakery algorithm: yet another specification and verification , 1993, Specification and validation methods.

[68]  Bart Demoen,et al.  A Framework to Specify Database Update Views for Prolog , 1991, PLILP.

[69]  Andreas Blass,et al.  The Linear Time Hierarchy Theorems for Abstract State Machines and RAMs , 1997, J. Univers. Comput. Sci..

[70]  Niklaus Wirth,et al.  Program development by step-wise refinement , 1971 .

[71]  Egon B Orger,et al.  A Mathematical Deenition of Full Prolog , 1994 .

[72]  C. A. R. Hoare.  The structure of an operating system , 1975, Language Hierarchies and Interfaces.

[73]  David Van Campenhout,et al.  Specification and verification of pipelining in the ARM2 RISC microprocessor , 1998, TODE.

[74]  Giuseppe Del Castillo,et al.  Towards Comprehensive Tool Support for Abstract State Machines: The ASM Workbench Tool Environment and Architecture , 1998, FM-Trends.

[75]  Peter H. Schmitt,et al.  A Formal Operational Semantics for Languages of Type Prolog III , 1990, CSL.

[76]  Florentin Ipate,et al.  Building Correct Systems , 1998 .

[77]  M. Shaw,et al.  The impact of abstraction concerns on modern programming languages , 1980, Proceedings of the IEEE.

[78]  Uwe Glasserb,et al.  A Formal Speciication of the Pvm Architecture , 1994 .

[79]  Peter Gorm Larsen,et al.  Modelling Systems - Practical Tools and Techniques in Software Development (2. ed.) , 1998 .

[80]  Andrew S. Tanenbaum,et al.  Structured Computer Organization , 1976 .

[81]  Peter D. Mosses.  Action Semantics , 1986, ADT.

[82]  Egon Börger.  Logic Programming: The Evolving Algebra Approach , 1994, IFIP Congress.

[83]  Professor Dr. Wolfgang Reisig.  Elements of Distributed Algorithms , 1998, Springer Berlin Heidelberg.

[84]  Egon Börger,et al.  A Practical Method for Rigorously Controllable Hardware Design , 1997, ZUM.

[85]  Yuri Gurevich,et al.  Metafinite Model Theory , 1994, LCC.

[86]  Luca Mearelli.  Refining an ASM Specification of the Production Cell to C++ Code , 1997, J. Univers. Comput. Sci..

[87]  Kirsten Winter,et al.  Model Checking for Abstract State Machines , 2008, J. Univers. Comput. Sci..

[88]  Dana S. Scott.  Some Definitional Suggestions for Automata Theory , 1967, J. Comput. Syst. Sci..

[89]  Peter D. Mosses,et al.  Denotational semantics , 1995, LICS 1995.

[90]  C. A. R. Hoare.  Mathematical models for computing science , 1996, NATO ASI DPD.

[91]  Parasuram Anantharam.  Modelling systems , 2000, SOEN.

[92]  Guy L. Steele,et al.  The Java Language Specification , 1996 .

[93]  Yuri Gurevich,et al.  The Sequential ASM Thesis , 2001, Bull. EATCS.

[94]  Hans Rischel,et al.  Design and prototyping of real-time systems using CSP and CML , 1997, Proceedings Ninth Euromicro Workshop on Real Time Systems.

[95]  Edsger W. Dijkstra,et al.  The structure of the “THE”-multiprogramming system , 1968, CACM.

[96]  Brian Randell,et al.  Iterative multi-level modelling. A methodology for computer system design , 1968, IFIP Congress.

[97]  Wolfram Hardt,et al.  Fast dynamic analysis of complex HW/SW-systems based on abstract state machine models , 1998, Proceedings of the Sixth International Workshop on Hardware/Software Codesign. (CODES/CASHE'98).

[98]  Lothar Thiele,et al.  Integrating Domain Specific Language Design in the Software Life Cycle , 1998, FM-Trends.

[99]  Marie-Laure Potet,et al.  Composition and Refinement in the B-Method , 1998, B.

[100]  David Lorge Parnas,et al.  SODAS and a methodology for system design , 1967, AFIPS '67 (Fall).

[101]  Wolfgang Müller,et al.  The semantics of behavioral VHDL '93 descriptions , 1994, EURO-DAC '94.

[102]  Brian Randell,et al.  Process Structuring , 1973, CSUR.

[103]  Edsger W. Dijkstra,et al.  Notes on structured programming , 1970 .

[104]  Egon Börger,et al.  A Logical Operational Semantics of Full Prolog, Part II: Built-in Predicates for Database Manipulation , 1990, MFCS.

[105]  Frank Waters,et al.  The B Book , 1971 .

[106]  Egon Börger,et al.  Integrating ASMs into the Software Development Life Cycle , 1997, J. Univers. Comput. Sci..

[107]  Don S. Batory,et al.  The design and implementation of hierarchical software systems with reusable components , 1992, TSEM.

[108]  Tsun S. Chow,et al.  Testing Software Design Modeled by Finite-State Machines , 1978, IEEE Transactions on Software Engineering.

[109]  Lilian Burdy,et al.  Well Defined B , 1998, B.

[110]  Egon Börger,et al.  A Logical Operational Semantics of Full Prolog. Part I: Selection Core and Control , 1989, CSL.

[111]  David Lorge Parnas,et al.  Tabular Representations in Relational Documents , 1997, Relational Methods in Computer Science.

[112]  Wolfgang Reisig,et al.  Distributed algorithms: modeling and analysis with Petri nets , 1998, SMC'98 Conference Proceedings. 1998 IEEE International Conference on Systems, Man, and Cybernetics (Cat. No.98CH36218).

[113]  Julius Richard Büchi,et al.  Finite automata, their algebras and grammars - towards a theory of formal expressions , 1989 .

[114]  Egon Börger,et al.  A Formal Specification of the PVM Architecture , 1994, IFIP Congress.

[115]  Egon Börger,et al.  A formal method for provably correct composition of a real-life processor out of basic components. (The APE100 Reverse Engineering Study) , 1995, Proceedings of First IEEE International Conference on Engineering of Complex Computer Systems. ICECCS'95.

[116]  Charles M. Shub,et al.  Discrete Event Simulation Languages , 1980 .