Software Abstractions - Logic, Language, and Analysis

In Software Abstractions Daniel Jackson introduces an approach to software design that draws on traditional formal methods but exploits automated tools to find flaws as early as possible. This approach--which Jackson calls "lightweight formal methods" or "agile modeling"--takes from formal specification the idea of a precise and expressive notation based on a tiny core of simple and robust concepts but replaces conventional analysis based on theorem proving with a fully automated analysis that gives designers immediate feedback. Jackson has developed Alloy, a language that captures the essence of software abstractions simply and succinctly, using a minimal toolkit of mathematical notions. This revised edition updates the text, examples, and appendixes to be fully compatible with the latest version of Alloy (Alloy 4). The designer can use automated analysis not only to correct errors but also to make models that are more precise and elegant. This approach, Jackson says, can rescue designers from "the tarpit of implementation technologies" and return them to thinking deeply about underlying concepts. Software Abstractions introduces the key elements: a logic, which provides the building blocks of the language; a language, which adds a small amount of syntax to the logic for structuring descriptions; and an analysis, a form of constraint solving that offers both simulation (generating sample states and executions) and checking (finding counterexamples to claimed properties).

[1]  Daniel Jackson,et al.  Alloy: a lightweight object modelling notation , 2002, TSEM.

[2]  G. Stålmarck,et al.  Modeling and Verifying Systems and Software in Propositional Logic , 1990 .

[3]  Jane Sinclair,et al.  Introduction to formal specification and Z , 1991, Prentice Hall International Series in Computer Science.

[4]  Bart Selman,et al.  Planning as Satisfiability , 1992, ECAI.

[5]  Michael D. Ernst,et al.  Automatic SAT-Compilation of Planning Problems , 1997, IJCAI.

[6]  Cliff B. Jones,et al.  Scientific Decisions which Characterize VDM , 1999, World Congress on Formal Methods.

[7]  Helen M. Edwards,et al.  Problem frames: analyzing and structuring software development problems , 2002, Softw. Test. Verification Reliab..

[8]  Cliff B. Jones,et al.  Systematic software development using VDM , 1986, Prentice Hall International Series in Computer Science.

[9]  Peter Gorm Larsen,et al.  The IFAD VDM Tools: Lightweight Formal Methods , 1998, FM-Trends.

[10]  Michael J. Butler,et al.  ProB: A Model Checker for B , 2003, FME.

[11]  Mark Richters,et al.  A precise approach to validating UML models and OCL constraints , 2002 .

[12]  Daniel Jackson,et al.  Elements of style: analyzing a software design feature with a counterexample detector , 1996, ISSTA '96.

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

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

[15]  Peter Gorm Larsen,et al.  Validated Designs for Object-oriented Systems , 2004 .

[16]  Martin Gogolla,et al.  Validation of UML and OCL Models by Automatic Snapshot Generation , 2003, UML.

[17]  C. A. R. Hoare,et al.  The emperor's old clothes , 1981, CACM.

[18]  E. F. CODD,et al.  A relational model of data for large shared data banks , 1970, CACM.

[19]  Viktor Kuncak,et al.  Decision Procedures for Set-Valued Fields , 2005, Electron. Notes Theor. Comput. Sci..

[20]  J. J. Horning,et al.  PRELIMINARY REPORT ON THE LARCH SHARED LANGUAGE , 1983 .

[21]  K. Beck,et al.  Extreme Programming Explained , 2002 .

[22]  J. J. Horning,et al.  Introduction to LCL, A Larch/C Interface Language , 1991 .

[23]  Raymond Reiter,et al.  The Frame Problem in the Situation Calculus: A Simple Solution (Sometimes) and a Completeness Result for Goal Regression , 1991, Artificial and Mathematical Theory of Computation.

[24]  Bo Stig Hansen,et al.  Information technology - Programming languages, their environments and system software interfaces: Vienna DevelopmentMethod - Specification Language - Part 1: Base language , 1996 .

[25]  Albert L. Baker,et al.  JML: A Notation for Detailed Design , 1999, Behavioral Specifications of Businesses and Systems.

[26]  Jim Woodcock,et al.  More Powerful Z Data Refinement: Pushing the State of the Art in Industrial Refinement , 1998, ZUM.

[27]  Martin Gogolla,et al.  On Formalizing the UML Object Constraint Language OCL , 1998, ER.

[28]  Daniel Jackson,et al.  An intermediate design language and its analysis , 1998, SIGSOFT '98/FSE-6.

[29]  Sharad Malik,et al.  Chaff: engineering an efficient SAT solver , 2001, Proceedings of the 38th Design Automation Conference (IEEE Cat. No.01CH37232).

[30]  Ernest J. H. Chang,et al.  An improved algorithm for decentralized extrema-finding in circular configurations of processes , 1979, CACM.

[31]  Martin Gogolla,et al.  Validating UML Models and OCL Constraints , 2000, UML.

[32]  A. Tarski,et al.  A Formalization Of Set Theory Without Variables , 1987 .

[33]  Andrew D. Irvine,et al.  Russell’s Paradox , 1995 .

[34]  Eric C. R. Hehner,et al.  Bunch Theory: A Simple Set Theory for Computer Science , 1981, Inf. Process. Lett..

[35]  John Mylopoulos,et al.  On the Frame Problem in Procedure Specifications , 1995, IEEE Trans. Software Eng..

[36]  J. McCarthy Situations, Actions, and Causal Laws , 1963 .

[37]  Daniel Jackson,et al.  Lightweight Formal Methods , 2001, FME.

[38]  Sharon L. Milgram,et al.  The Small World Problem , 1967 .

[39]  Daniel Jackson,et al.  Declarative symbolic pure-logic model checking , 2005 .

[40]  Robert K. Brayton,et al.  Combinational test generation using satisfiability , 1996, IEEE Trans. Comput. Aided Des. Integr. Circuits Syst..

[41]  Martin Gogolla,et al.  USE: A UML-based specification environment for validating UML and OCL , 2007, Sci. Comput. Program..

[42]  John Daniels,et al.  Designing object systems: object-oriented modelling with Syntropy , 1995 .

[43]  C. D. Walter Algorithmics–The spirit of computing , 1988 .

[44]  Emina Torlak,et al.  A type system for object models , 2004, SIGSOFT '04/FSE-12.

[45]  Ilya Shlyakhter,et al.  Generating effective symmetry-breaking predicates for search problems , 2001, Discrete Applied Mathematics.

[46]  C. A. R. Hoare,et al.  Proof of correctness of data representations , 1972, Acta Informatica.

[47]  Daniel Jackson Boolean Compilation of Relational Specifications , 1998 .

[48]  Steve Schneider The B-method - an introduction , 2001, The cornerstones of computing series.

[49]  Viktor Kuncak,et al.  Relational analysis of algebraic datatypes , 2005, ESEC/FSE-13.

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

[51]  Paul R. Halmos Problems for mathematicians, young and old , 1991 .

[52]  Somesh Jha,et al.  Isomorph-free model enumeration: a new method for checking relational specifications , 1998, TOPL.

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

[54]  Carrol Morgan Telephone network , 1987 .

[55]  Yuri Gurevich,et al.  The Classical Decision Problem , 1997, Perspectives in Mathematical Logic.

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

[57]  Ian J. Hayes,et al.  Specification case studies , 1987 .

[58]  James J. Horning,et al.  Formal specification as a design tool , 1980, POPL '80.

[59]  Anneke Kleppe,et al.  The Object Constraint Language: Getting Your Models Ready for MDA , 2003 .

[60]  Kevin Lano,et al.  Specification in B: An Introduction Using the B Toolkit , 1996 .

[61]  John Wordsworth Software development with Z - a practical approach to formal methods in software engineering , 1992, International computer science series.

[62]  Jim Woodcock,et al.  An Electronic Purse: Specification, Refinement and Proof , 2000 .

[63]  Somesh Jha,et al.  Checking relational specifications with binary decision diagrams , 1996, SIGSOFT '96.

[64]  Eugene Goldberg,et al.  BerkMin: A Fast and Robust Sat-Solver , 2002, Discret. Appl. Math..

[65]  Zohar Manna,et al.  The Temporal Logic of Reactive and Concurrent Systems , 1991, Springer New York.