Modular Specification and Verification of Object-Oriented Programs

Mojave and the Universe Type System.- The Semantics of Mojave.- Modular Specification and Verification of Functional Behavior.- Modular Specification and Verification of Frame Properties.- Modular Specification and Verification of Type Invariants.- Conclusion.- Formal Background and Notations.- Predefined Type Declarations.- Examples.- Auxiliary Lemmas, Proofs, and Models.

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

[2]  C. A. R. Hoare,et al.  An Axiomatic Definition of the Programming Language PASCAL , 1973, Acta Informatica.

[3]  Susan S. Owicki,et al.  Axiomatic Proof Techniques for Parallel Programs , 1975, Outstanding Dissertations in the Computer Sciences.

[4]  C. A. R. Hoare,et al.  Proof of correctness of data representation , 1975, Language Hierarchies and Interfaces.

[5]  Norihisa Suzuki.  Automatic Verification of Programs with Complex Data Structures , 1976, Outstanding Dissertations in the Computer Sciences.

[6]  Joseph A. Goguen,et al.  Putting Theories Together to Make Specifications , 1977, IJCAI.

[7]  Jeffrey D. Ullman,et al.  Introduction to Automata Theory, Languages and Computation , 1979 .

[8]  Edward Nash Yourdon.  Classics in Software Engineering , 1979 .

[9]  John McCarthy,et al.  SOME PHILOSOPHICAL PROBLEMS FROM THE STANDPOINT OF ARTI CIAL INTELLIGENCE , 1987 .

[10]  Zohar Manna,et al.  Logics of Programs , 1981, Lecture Notes in Computer Science.

[11]  Krzysztof R. Apt,et al.  Ten Years of Hoare's Logic: A Survey—Part I , 1981, TOPL.

[12]  James W. Thatcher,et al.  Data Type Specification: Parameterization and the Power of Specification Techniques , 1982, TOPL.

[13]  Will D. Gillett,et al.  An Introduction to Engineered Software , 1982 .

[14]  Bent Bruun Kristensen,et al.  Abstraction mechanisms in the BETA programming language , 1983, POPL '83.

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

[16]  José Meseguer,et al.  Principles of OBJ2 , 1985, POPL.

[17]  Bertrand Meyer,et al.  Genericity versus inheritance , 1986, OOPLSA '86.

[18]  Alan Snyder.  Encapsulation and inheritance in object-oriented programming languages , 1986, OOPSLA 1986.

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

[20]  Bjarne Stroustrup,et al.  C++ Programming Language , 1986, IEEE Softw..

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

[22]  John Elder,et al.  Introduction to Modula-2 , 1987, Prentice Hall International Series in Computer Science.

[23]  Alan Snyder,et al.  Inheritance and the Development of Encapsulated Software Systems , 1987, Research Directions in Object-Oriented Programming.

[24]  Pierre America,et al.  Inheritance and Subtyping in a Parallel Object-Oriented Language , 1987, ECOOP.

[25]  V. Stavridou,et al.  Abstraction and specification in program development , 1988 .

[26]  Donald Sannella,et al.  Specifications in an Arbitrary Institution , 1988, Inf. Comput..

[27]  Niklaus Wirth,et al.  From modula to oberon , 1988, Softw. Pract. Exp..

[28]  A. Bijlsma.  Calculating with Pointers , 1989, Sci. Comput. Program..

[29]  Todd Leavens Gary.  Verifying object-oriented programs that use subtypes , 1989 .

[30]  David A. Carrington,et al.  Object-Z: An Object-Oriented Extension to Z , 1989, FORTE.

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

[32]  Philip Wadler,et al.  Linear Types can Change the World! , 1990, Programming Concepts and Methods.

[33]  Patrick Cousot,et al.  Methods and Logics for Proving Programs , 1991, Handbook of Theoretical Computer Science, Volume B: Formal Models and Sematics.

[34]  Wolfgang Polak,et al.  Formal Verification of Ada Programs , 1990, IEEE Trans. Software Eng..

[35]  Pierre America,et al.  Designing an Object-Oriented Programming Language with Behavioural Subtyping , 1990, REX Workshop.

[36]  Carroll Morgan,et al.  Programming from specifications , 1990, Prentice Hall International Series in computer science.

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

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

[39]  William R. Cook,et al.  Mixin-based inheritance , 1990, OOPSLA/ECOOP '90.

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

[41]  Ian Holyer.  Functional programming with Miranda , 1991 .

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

[43]  P. America,et al.  A behavioural approach to subtyping in object-oriented programming languages , 1991 .

[44]  Bjarne Stroustrup,et al.  The C++ programming language (2nd ed.) , 1991 .

[45]  John Hogg,et al.  Islands: aliasing protection in object-oriented languages , 1991, OOPSLA '91.

[46]  Bertrand Meyer,et al.  Eiffel: The Language , 1991 .

[47]  Stephen J. Garland,et al.  A Guide to LP, The Larch Prover , 1991 .

[48]  Greg Nelson,et al.  Systems programming in modula-3 , 1991 .

[49]  Gilad Bracha,et al.  The programming language jigsaw: mixins, modularity and multiple inheritance , 1992 .

[50]  Richard C. Holt,et al.  The Geneva convention on the treatment of object aliasing , 1992, OOPS.

[51]  Clemens A. Szyperski,et al.  Import is Not Inheritance - Why We Need Both: Modules and Classes , 1992, ECOOP.

[52]  Gilad Bracha,et al.  Modularity meets inheritance , 1992, Proceedings of the 1992 International Conference on Computer Languages.

[53]  Ken Robinson,et al.  Modular Reasoning in an Object-Oriented Refinement Calculus , 1992, MPC.

[54]  Kevin Lano,et al.  Reasoning and Refinement in Object-Oriented Specification Languages , 1992, ECOOP.

[55]  J. van Katwijk,et al.  VDM++, a formal specification language for object-oriented designs , 1992, CompEuro 1992 Proceedings Computer Systems and Software Engineering.

[56]  Kurt Stenzel,et al.  Reuse of Proofs in Software Verification , 1993, FSTTCS.

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

[58]  Eric C. R. Hehner.  A Practical Theory of Programming , 1993, Texts and Monographs in Computer Science.

[59]  R. Aho,et al.  Pruning Duplicate Nodes in Depth-First Search , 1993 .

[60]  Robert W. Floyd,et al.  Assigning Meanings to Programs , 1993 .

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

[62]  Gerald W. Both,et al.  Object-oriented analysis and design with applications , 1994 .

[63]  Gary T. Leavens,et al.  The Larch/Smalltalk interface specification language , 1994, TSEM.

[64]  Clemens A. Szyperski,et al.  Engineering a Programming Language: The Type and Class System of Sather , 1994, Programming Languages and System Architectures.

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

[66]  Andreas Ruping.  Modules In Object-Oriented Systems , 1994 .

[67]  Gary Lindstrom,et al.  Type-safe Composition of Object Modules , 1994 .

[68]  Andrew C. Myers,et al.  Subtypes vs. where clauses: constraining parametric polymorphism , 1995, OOPSLA.

[69]  Deri Sheppard.  An introduction to formal specification with Z and VDM , 1995, McGrawhill international series in software engineering.

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

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

[72]  Jeannette M. Wing,et al.  Specification matching of software components , 1995, TSEM.

[73]  Guruduth S. Banavar,et al.  An application framework for compositional modularity , 1995 .

[74]  Wolfgang Reif,et al.  The KIV-Approach to Software Verification , 1995, KORSO Book.

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

[76]  Bjarne Steensgaard,et al.  Points-to analysis in almost linear time , 1996, POPL '96.

[77]  Naftaly H. Minsky.  Towards Alias-Free Pointers , 1996, ECOOP.

[78]  K. Rustan M. Leino.  A myth in the modular specification of programs , 1996 .

[79]  Monti Ben-Ari,et al.  Understanding Programming Languages , 1996 .

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

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

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

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

[84]  Peter Müller,et al.  Programming and Interface Specification Language of JIVE: Specification and Design Rationale , 1997 .

[85]  Raymie Stata,et al.  Checking object invariants , 1997 .

[86]  Martin Odersky,et al.  Pizza into Java: translating theory into practice , 1997, POPL '97.

[87]  Kim B. Bruce,et al.  Subtyping Is Not a Good "Match" for Object-Oriented Languages , 1997, ECOOP.

[88]  Paulo Sérgio Almeida.  Balloon Types: Controlling Sharing of State in Data Types , 1997, ECOOP.

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

[90]  Arnd Poetzsch-Heffter.  Prototyping realistic programming languages based on formal specifications , 1997, Acta Informatica.

[91]  Christian Prehofer,et al.  Feature-Oriented Programming: A Fresh Look at Objects , 1997, ECOOP.

[92]  Arnd Poetzsch-Heffter,et al.  Specification and verification of object-oriented programs , 1997 .

[93]  Martín Abadi,et al.  A Logic of Object-Oriented Programs , 1997, Verification: Theory and Practice.

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

[95]  Anneke Kleppe,et al.  The object constraint language: precise modeling with UML , 1998 .

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

[97]  Martin Trapp,et al.  An Approach to Improve Locality Using Sandwich Types , 1998, Types in Compilation.

[98]  Mandayam K. Srivas,et al.  A Tutorial Introduction to PVS , 1998 .

[99]  Arnd Poetzsch-Heffter,et al.  Logical foundations for typed object-oriented languages , 1998, PROCOMET.

[100]  Greg Nelson,et al.  Wrestling with rep exposure , 1998 .

[101]  Jan Vitek,et al.  Flexible Alias Protection , 1998, ECOOP.

[102]  Tobias Nipkow,et al.  Javalight is type-safe—definitely , 1998, POPL '98.

[103]  James Noble,et al.  Ownership types for flexible alias protection , 1998, OOPSLA '98.

[104]  K. Rustan M. Leino,et al.  Data groups: specifying the modification of extended state , 1998, OOPSLA '98.

[105]  Clemens Fischer,et al.  JaWa: Java with Assertions , 1998, Java-Informations-Tage.

[106]  Hendrik Tews,et al.  Reasoning about Java Classes (Preliminary Report) , 1998, Conference on Object-Oriented Programming Systems, Languages, and Applications.

[107]  Kurt Stenzel,et al.  Structured Specifications and Interactive Proofs with KIV , 1998 .

[108]  Peter Müller,et al.  Kapselung und Methodenbindung: Javas Designprobleme und ihre Korrektur , 1998, Java-Informations-Tage.

[109]  Michael Benedikt,et al.  A Decidable Logic for Describing Linked Data Structures , 1999, ESOP.

[110]  Bart Jacobs,et al.  Formal Techniques for Java Programs , 1999, ECOOP Workshops.

[111]  Frank Pfenning,et al.  Dependent types in practical programming , 1999, POPL '99.

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

[113]  Tobias Nipkow,et al.  Machine-Checking the Java Specification: Proving Type-Safety , 1999, Formal Syntax and Semantics of Java.

[114]  David von Oheimb.  Hoare Logic for Mutual Recursion and Local Variables , 1999, FSTTCS.

[115]  K. Rustan M. Leino,et al.  Virginity: A Contribution to the Specification of Object-Oriented Software , 1999, Inf. Process. Lett..

[116]  K. Rustan M. Leino,et al.  Checking Java Programs via Guarded Commands , 1999, ECOOP Workshops.

[117]  Jan Vitek,et al.  Confined types , 1999, OOPSLA '99.

[118]  Frank S. de Boer,et al.  A WP-calculus for OO , 1999, FoSSaCS.

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

[120]  Albert L. Baker,et al.  Enhancing the Pre- and Postcondition Technique for More Expressive Specifications , 1999, World Congress on Formal Methods.

[121]  Peter M Uller,et al.  Universes: a type system for controlling representation exposure , 1999 .

[122]  Arnd Poetzsch-Heffter,et al.  A Programming Logic for Sequential Java , 1999, ESOP.

[123]  Arnd Poetzsch-Heffter,et al.  Making Executable Interface Specifications More Expressive , 1999, Java-Informations-Tage.

[124]  Arnd Poetzsch-Heffter,et al.  Alias Control Is Crucial for Modular Verification of Object-Oriented Programs , 1999, ECOOP Workshops.

[125]  Safely creating correct subclasses without seeing superclass code , 2000, OOPSLA '00.

[126]  Peter Müller,et al.  Formal Verification of a Doubly Linked List Implementation: A Case Study Using the JIVE System , 2000 .

[127]  Arnd Poetzsch-Heffter.  Konzepte objektorientierter Programmierung , 2000 .

[128]  Ruurd Kuiper,et al.  Verification of Object Oriented Programs Using Class Invariants , 2000, FASE.

[129]  Arnd Poetzsch-Heffter,et al.  An Architecture for Interactive Program Provers , 2000, TACAS.

[130]  Gary T. Leavens,et al.  Concepts of behavioral subtyping and a sketch of their extension to component-based systems , 2000 .

[131]  Bart Jacobs,et al.  Java Program Verification via a Hoare Logic with Abrupt Termination , 2000, FASE.

[132]  Reinhard Wilhelm,et al.  Shape Analysis , 2000, CC.

[133]  Arnd Poetzsch-Heffter,et al.  Modular specification and verification techniques for object-oriented software components , 2000 .

[134]  James Noble.  Aliasing in Object-Oriented Systems , 2001, Softw. Focus.

[135]  Atsushi Igarashi,et al.  On Inner Classes , 2002, Inf. Comput..

[136]  K. Rustan M. Leino,et al.  Data abstraction and information hiding , 2002, TOPL.

[137]  Hannu Koivisto.  Aspect-oriented programming in common lisp , 2002 .

[138]  Walter Dosch,et al.  On hierarchies of abstract data types , 1983, Acta Informatica.

[139]  M. Sitaraman.  Using Abstraction Relations to Verify Abstract Data Type Representations , .

[140]  Preserving the Correctness of Object-Oriented Programs under Extension , .