Enhancing the Pre- and Postcondition Technique for More Expressive Specifications

We describe enhancements to the pre- and postcondition technique that help specifications convey information more effectively. Some enhancements allow one to specify redundant information that can be used in "debugging" specifications. For instance, adding examples to a specification gives redundant information that may aid some readers, and can also be used to help ensure that the specification says what is intended. Other enhancements allow improvements in frame axioms for object-oriented (OO) procedures, better treatments of exceptions and inheritance, and improved support for incompletely-specified types. Many of these enhancements were invented by other authors, but are not widely known. They have all been integrated into Larch/C++, a Larch-style behavioral interface specification language for C++. However, such enhancements could also be used to make other specification languages more effective tools for communication.

[1]  Krishna Kishore Dhara,et al.  Behavioral subtyping in object-oriented languages , 1997 .

[2]  David S. Rosenblum.  A Practical Approach to Programming With Assertions , 1995, IEEE Trans. Software Eng..

[3]  David Gries,et al.  Teaching calculation and discrimination: a more effective curriculum , 1991, CACM.

[4]  Emil Sekerinski,et al.  Formal Methods for Component Software: The Refinement Calculus Perspective , 1997, ECOOP Workshops.

[5]  Richard Southwell.  The Imperial College , 1949 .

[6]  Jim Woodcock,et al.  FME'96: Industrial Benefit and Advances in Formal Methods , 1996, Lecture Notes in Computer Science.

[7]  David C. Luckham.  Programming with Specifications: An Introduction to ANNA, A Language for Specifying Ada Programs , 1990 .

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

[9]  K. Rustan M. Leino,et al.  Extended static checking , 1998, PROCOMET.

[10]  Dewayne E. Perry.  The inscape environment , 1989, ICSE '89.

[11]  Peter Grogono,et al.  On the language design and semantic foundation of lcl, a larch/c interface specification language , 1996 .

[12]  Yang Meng Tan.  Formal specification techniques for promoting software modularity, enhancing documentation, and testing specifications , 1994 .

[13]  Greg Nelson,et al.  A generalization of Dijkstra's calculus , 1989, ACM Trans. Program. Lang. Syst..

[14]  Curtis Charles Clifton,et al.  MultiJava: Design, implementation, and evaluation of a Java-compatible language supporting modular open classes and symmetric multiple dispatch , 2001 .

[15]  Gary T. Leavens,et al.  Larch/C++ Reference Manual , 1999 .

[16]  Carroll Morgan,et al.  The Refinement Calculus , 1994, NATO ASI PDC.

[17]  Stephen J. Garland,et al.  Debugging Larch Shared Language Specifications , 1990, IEEE Trans. Software Eng..

[18]  Sankar Gowri Sivaprasad.  Larch/CORBA: Specifying the Behavior of CORBA-IDL Interfaces , 1995 .

[19]  Gary T. Leavens,et al.  Typed Homomorphic Relations Extended with Sybtypes , 1991, MFPS.

[20]  Jeannette M. Wing.  A TWO-TIERED APPROACH TO SPECIFYING PROGRAMS , 1983 .

[21]  Gary T. Leavens,et al.  Reasoning about object-oriented programs that use subtypes , 1990, OOPSLA/ECOOP '90.

[22]  Richard L. Wexelblat,et al.  Proceedings of the Workshop on Interface Definition Languages, January 20, 1994, Portland, Oregon, USA, in conjunction with POPL 1994 , 1994, IDL.

[23]  David C. Luckham,et al.  An Overview of Anna, a Specification Language for Ada , 1985, IEEE Software.

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

[25]  Cliff B. Jones,et al.  Partial Functions and Logics: A Warning , 1995, Inf. Process. Lett..

[26]  Yang Meng Tan.  Interface Language for Supporting Programming Styles , 1994, Workshop on Interface Definition Languages.

[27]  Gary T. Leavens,et al.  Protective Interface Specifications , 1997, Formal Aspects of Computing.

[28]  Clyde Ruby.  Safely creating correct subclasses without seeing superclass code , 2000, OOPSLA Addendum.

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

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

[31]  Peter Gorm Larsen,et al.  Modelling Systems: Practical Tools and Techniques in Software Development , 1998 .

[32]  Gary T. Leavens.  An Overview of Larch/C++: Behavioral Specifications for C++ Modules , 1996 .

[33]  Edsger W. Dijkstra,et al.  A Discipline of Programming , 1976 .

[34]  C. A. R. HOARE,et al.  An axiomatic basis for computer programming , 1969, CACM.

[35]  Martin Gogolla,et al.  TROLL light - The Language and its Development Environment , 1995, KORSO Book.

[36]  Medhat Assaad.  Alias-free parameters in C using multibodies , 2001 .

[37]  Edsger W. Dijkstra,et al.  Formal Development of Programs and Proofs , 1990 .

[38]  Edsger W. Dijkstra,et al.  Predicate Calculus and Program Semantics , 1989, Texts and Monographs in Computer Science.

[39]  Bill Harvey,et al.  Specification of behavioral semantics in object-oriented information modeling , 1994, OOPS Messenger.

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

[41]  Yang Meng Tan.  Formal Specification Techniques for Engineering Modular C Programs , 1996, The Springer International Series in Software Engineering.

[42]  Gary T. Leavens,et al.  MultiJava: modular open classes and symmetric multiple dispatch for Java , 2000, OOPSLA '00.

[43]  Jeannette M. Wing.  Writing Larch interface language specifications , 1987, TOPL.

[44]  Gary T. Leavens,et al.  Forcing behavioral subtyping through specification inheritance , 1996, Proceedings of IEEE 18th International Conference on Software Engineering.

[45]  Kevin D. Jones.  LM3: A Larch interface language for Modula - 3: A definition and introduction: Version 1 , 1991 .

[46]  Gary T. Leavens,et al.  Weak behavioral subtyping for types with mutable objects , 1995, MFPS.

[47]  Jan Madey,et al.  The Z notation: A reference manual , 1990 .

[48]  Derek J. Andrews.  A theory and practice of program development , 1997, FACIT: Formal approaches to computing and information technology.

[49]  Fred B. Schneider,et al.  Avoiding the Undefined by Underspecification , 1995, Computer Science Today.

[50]  Gary T. Leavens,et al.  Subtyping for Mutable Types in Object-Oriented Programming Languages , 1992 .

[51]  R. Reiter,et al.  - 1-On the Frame Problem in Procedure Specifications , 1993 .

[52]  Shekhar H. Kirani.  Speci~cation and veri~cation of object-oriented programs , 1994 .

[53]  Ralph-Johan Back,et al.  Refinement Calculus: A Systematic Introduction , 1998 .

[54]  Matthew W. Markland.  Design and Implementation of the Larch/C++ Type System , 1995 .

[55]  Gary T. Leavens,et al.  Formal semantics of an algorithm for translating model-based specifications to concurrent constraint programs , 2001, SAC.

[56]  Hua Zhong,et al.  LSL Traits for using Z with Larch , 1997 .

[57]  Albert L. Baker,et al.  Formal semantics for SA style data flow diagram specification languages , 1999, SAC '99.

[58]  Timothy Allen Wahls,et al.  On the execution of high level formal specifications , 1995 .

[59]  Yoonsik Cheon,et al.  Larch/Smalltalk: A Specification Language for Smalltalk , 1991 .

[60]  簡聰富,et al.  物件導向軟體之架構(Object-Oriented Software Construction)探討 , 1989 .

[61]  J. Back,et al.  Combining Angels, Demons and Miracles in Program Speciications , 1989 .

[62]  Susan Stepney,et al.  Why an Object Oriented Z? , 1992, Object Orientation in Z.

[63]  P. Mainguet,et al.  Executive committee , 1991, Acta Endoscopica.

[64]  Wim H. Hesselink.  Programs, Recursion and Unbounded Choice , 1992 .

[65]  K. R Leino,et al.  Towards Reliable Modular Programs , 1995 .

[66]  Susan Stepney,et al.  Object Orientation in Z , 1992, Workshops in Computing.

[67]  Gary T. Leavens,et al.  Polymorphic Type-Checking in Scheme , 1996, Comput. Lang..

[68]  Gerhard Goos,et al.  Computer Science Today: Recent Trends and Developments , 1995 .

[69]  David M. Egle.  Evaluating Larch/C++ as a Specification Language = A Case Study Using the Microsoft Foundation Class Library , 1995 .

[70]  L. M. G. Feijs,et al.  Formal Specification and Design: From algebras to states , 1992 .

[71]  Arun Raghavan,et al.  Design of a JML Documentation Generator , 2000 .

[72]  Ralph-Johan Back,et al.  Combining Angles, Demons and Miracles in Program Specifications , 1992, Theor. Comput. Sci..

[73]  T. Leavens,et al.  Protective Interface Speci cations , 1997 .

[74]  Edward L. Jones,et al.  Software testing in the computer science curriculum -- a holistic approach , 2000, ACSE '00.

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

[76]  Jeannette M. Wing,et al.  Specifications and their use in defining subtypes , 1993, OOPSLA '93.

[77]  H. B. M. Jonkers.  Upgrading the Pre- and Postcondition Technique , 1991, VDM Europe.

[78]  Alan Wills.  Specification in Fresco , 1992, Object Orientation in Z.

[79]  Peter Grogono,et al.  Identification of and Solutions to Shortcomings of LCL, a Larch/C Interface Specification Language , 1996, FME.

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

[81]  Jeannette M. Wing,et al.  A behavioral notion of subtyping , 1994, TOPL.

[82]  L. M. G. Feijs,et al.  Formal Specification and Design , 1992 .

[83]  Manfred Broy,et al.  KORSO: Methods, Languages, and Tools for the Construction of Correct Software , 1995, Lecture Notes in Computer Science.

[84]  Gary T. Leavens.  Formal methods for multimethod software components , 2000, SOEN.

[85]  Gary T. Leavens,et al.  Typechecking and modules for multi-methods , 1994, OOPSLA '94.

[86]  Gary T. Leavens,et al.  Multiple dispatch as dispatch on Tuples , 1998, OOPSLA '98.

[87]  Stuart H. Zweben,et al.  Part I: the RESOLVE framework and discipline: a research synopsis , 1994, SOEN.

[88]  J. Davenport.  Editor , 1960 .

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

[90]  Lonnie R. Welch,et al.  On Specification of Reusable Software Components , 1993, Int. J. Softw. Eng. Knowl. Eng..

[91]  Joseph M. Morris,et al.  A Theoretical Basis for Stepwise Refinement and the Programming Calculus , 1987, Sci. Comput. Program..