Academia.eduAcademia.edu

Outline

Title
Abstract
Introduction
Related Work
References
All Topics
Computer Science
Software Engineering

Modular specification of frame properties in JML

Profile image of Ruurd KuiperRuurd Kuiper

2003, Concurrency and Computation: Practice and Experience

Abstract

We present a modular specification technique for frame properties. The technique uses modifies clauses and abstract fields with declared dependencies. Modularity is guaranteed by a programming model that restricts aliasing, and by modularity requirements for dependencies. For concreteness, we adapt this technique to the Java Modeling Language, JML.

Related papers

An overview of JML tools and applications1
Dermot Cochran

2003

The Java Modeling Language (JML) can be used to specify the detailed design of Java classes and interfaces by adding annotations to Java source files. The aim of JML is to provide a specification language that is easy to use for Java programmers and that is supported by a wide range of tools for specification typechecking, runtime debugging, static analysis, and verification.

View PDFchevron_right
Modular Specification of Java Programs
Alain Giorgetti, Olga Kouchnarenko

2009

This work investigates the question of modular specification of generic Java classes and methods. The first part introduces a specification language for Java programs. In the second part the language is used to specify an array sorting algorithm by selection. The third and the fourth parts define a syntax proposal for the specification a generic Java programs, through two examples. The former is the specification of the generic method for sorting arrays which comes in the java.util.Arrays class of the Java API. The latter is the specification of the java.util.HashMap class and its use for memoization.

View PDFchevron_right
Beyond Assertions: Advanced Specification and Verification With JML and ESC/Java2
Joseph Kiniry

Formal Methods for Components …, 2006

View PDFchevron_right
An Overview of JML Tools and Applications
Joseph Kiniry

International Journal on …, 2005

View PDFchevron_right
An Idealized MetaML: Simpler, and More Expressive
Walid Mohamed Rashad Mohamed

Lecture Notes in Computer Science, 1999

MetaML is a multi-stage functional programming language featuring three constructs that can be viewed as statically-typed refinements of the back-quote, comma, and eval of Scheme. Thus it provides special support for writing code generators and serves as a semanticallysound basis for systems involving multiple interdependent computational stages. In previous work, we reported on an implementation of MetaML, and on a reduction semantics and type-system for MetaML. In this paper, we present An Idealized MetaML (AIM) that is the result of our study of a categorical model for MetaML. An important outstanding problem is finding a type system that provides the user with a means for manipulating both open and closed code. This problem has eluded efforts by us and other researchers for over three years. AIM solves the issue by providing two type constructors, one classifies closed code and the other open code, and exploiting the way they interact. We point out that AIM can be verbose, and outline a possible remedy relating to the strictness of the closed code type.

View PDFchevron_right
How the design of JML accommodates both runtime assertion checking and formal verification
G. Leavens

Science of Computer Programming, 2005

Specifications that are used in detailed design and in the documentation of existing code are primarily written and read by programmers. However, most formal specification languages either make heavy use of symbolic mathematical operators, which discourages use by programmers, or limit assertions to expressions of the underlying programming language, which makes it difficult to write complete specifications. Moreover, using assertions that are expressions in the underlying programming language can cause problems both in runtime assertion checking and in formal verification, because such expressions can potentially contain side effects. The Java Modeling Language, JML, avoids these problems. It uses a side-effect free subset of Java's expressions to which are added a few mathematical operators (such as the quantifiers \forall and \exists). JML also hides mathematical abstractions, such as sets and sequences, within a library of Java classes. The goal is to allow JML to serve as a common notation for both formal verification and runtime assertion checking; this gives users the benefit of several tools without the cost of changing notations.

View PDFchevron_right
Extending JML Specifications with Temporal Logic
Marieke Huisman

Lecture Notes in Computer Science, 2002

This paper proposes an extension of the Java Modeling Lan- guage (JML) with temporal specifications. The extension is inspired by the patterns and specification language used within the Bandera project, and is especially tailored to specify properties of Java(Card) programs; for example, it allows the exceptional behaviour of methods to be spec- ified. In the tradition of JML, the extension

View PDFchevron_right
JML: A Notation for Detailed Design
Gary Leavens

Behavioral Specifications of Businesses and Systems, 1999

View PDFchevron_right
Specification Matching for JML-annotated Java
Dermot Cochran

Abstract In 1997 Zaremski and Wing introduced definitions of specification matching of software components and implemented a system according to these definitions for components written in the ML programming language with specifications in the Larch/ML specification language [ZW97].

View PDFchevron_right
A component-based approach for specifying DSML's concrete syntax
Cédric Dumoulin, Amine Kouhen

Proceedings of the Second Workshop on Graphical Modeling Language Development - GMLD '13, 2013

Model-Driven Engineering (MDE) encourages the use of graphical modeling tools, which facilitate the development process from modeling to coding. Such tools can be designed using the MDE approach into meta-modeling environments called metaCASE tools.

View PDFchevron_right

References (18)

  1. Alex Borgida, John Mylopoulos, and Rayomnd Reiter. On the frame prob- lem in procedure specifications. IEEE Transactions on Software Engineer- ing, 21(10):785-798, October 1995.
  2. D. G. Clarke, J. Noble, and J. M. Potter. Simple ownership types for containment. In European Conference on Object-Oriented Programming, ECOOP 2001, Lecture Notes in Computer Science. Springer-Verlag, 2001. (to appear).
  3. D. G. Clarke, J. M. Potter, and J. Noble. Ownership types for flexible alias protection. In Proceedings of Object-Oriented Programming Systems, Languages, and Applications (OOPSLA), volume 33(10) of ACM SIGPLAN Notices, October 1998.
  4. DEJ + 00] Sophia Drossopoulou, Susan Eisenbach, Bart Jacobs, Gary T. Leavens, Pe- ter Müller, and Arnd Poetzsch-Heffter. Formal techniques for Java pro- grams. In Jacques Malenfant, Sabine Moisan, and Ana Moreira, editors, Object-Oriented Technology. ECOOP 2000 Workshop Reader, volume 1964 of Lecture Notes in Computer Science, pages 41-54. Springer-Verlag, 2000.
  5. Krishna Kishore Dhara and Gary T. Leavens. Forcing behavioral subtyp- ing through specification inheritance. In Proceedings of the 18th Interna- tional Conference on Software Engineering, Berlin, Germany, pages 258- 267. IEEE Computer Society Press, March 1996. A corrected version is Iowa State University, Dept. of Computer Science TR #95-20c.
  6. GHG + 93] John V. Guttag, James J. Horning, S.J. Garland, K.D. Jones, A. Modet, and J.M. Wing. Larch: Languages and Tools for Formal Specification. Springer-Verlag, New York, NY, 1993.
  7. Gary T. Leavens, Albert L. Baker, and Clyde Ruby. JML: A notation for detailed design. In Haim Kilov, Bernhard Rumpe, and Ian Simmonds, editors, Behavioral Specifications of Businesses and Systems, pages 175-188. Kluwer Academic Publishers, Boston, 1999.
  8. Gary T. Leavens, Albert L. Baker, and Clyde Ruby. Preliminary design of JML: A behavioral interface specification language for Java. Technical Report 98-06m, Iowa State University, Department of Computer Science, February 2001. See www.cs.iastate.edu/~leavens/JML.html.
  9. K. Rustan M. Leino. Toward Reliable Modular Programs. PhD thesis, California Institute of Technology, 1995. Available as Technical Report Caltech-CS-TR-95-03.
  10. K. Rustan M. Leino. Data groups: Specifying the modification of extended state. In OOPSLA '98 Conference Proceedings, volume 33(10) of ACM SIGPLAN Notices, pages 144-153. ACM, October 1998.
  11. K. Lano and H. Haughton, editors. Object-Oriented Specification Case Stud- ies. The Object-Oriented Series. Prentice Hall, New York, NY, 1994.
  12. K. Rustan M. Leino and Greg Nelson. Data abstraction and information hiding. Technical Report 160, Compaq Systems Research Center, 130 Lytton Avenue Palo Alto, CA 94301, 2000.
  13. Barbara Liskov and Jeannette Wing. A behavioral notion of subtyping. ACM Transactions on Programming Languages and Systems, 16(6):1811- 1841, November 1994.
  14. Peter Müller and Arnd Poetzsch-Heffter. A type system for controlling representation exposure in Java. Published in [DEJ + 00]., 2000.
  15. P. Müller and A. Poetzsch-Heffter. Universes: A type system for alias and dependency control. Technical Report 279, FernUniversität Hagen, 2001.
  16. Peter Müller. Modular Specification and Verification of Object-Oriented programs. PhD thesis, FernUniversität Hagen, Germany, March 2001.
  17. Susan Stepney, Rosalind Barden, and David Cooper, editors. Object Ori- entation in Z. Workshops in Computing. Springer-Verlag, Cambridge CB2 1LQ, UK, 1992.
  18. Jeannette M. Wing. Writing Larch interface language specifications. ACM Transactions on Programming Languages and Systems, 9(1):1-24, January 1987.

Related papers

A JML Tutorial: Modular Specification and Verification of Functional Behavior for Java
Gary Leavens

Lecture Notes in Computer Science, 2007

JML, the Java Modeling Language, is the lingua franca of researchers working on specification and verification techniques and tools for Java. There are over 23 research groups worldwide working on various aspects of the JML project. These groups have built a large suite of tools for automated checking and verification (see http://jmlspecs. org).

View PDFchevron_right
Preliminary design of JML
G. Leavens

ACM SIGSOFT Software Engineering Notes, 2006

JML is a behavioral interface specification language tailored to Java(TM). Besides pre-and postconditions, it also allows assertions to be intermixed with Java code; these aid verification and debugging. JML is designed to be used by working software engineers; to do this it follows Eiffel in using Java expressions in assertions. JML combines this idea from Eiffel with the model-based approach to specifications, typified by VDM and Larch, which results in greater expressiveness. Other expressiveness advantages over Eiffel include quantifiers, specification-only variables, and frame conditions. This paper discusses the goals of JML, the overall approach, and describes the basic features of the language through examples. It is intended for readers who have some familiarity with both Java and behavioral specification using preand postconditions.

View PDFchevron_right
Adding native specifications to JML
Julien Charles

2006

In the specification language JML we can see pure methods as a way to express user-defined predicates that will simplify the annotations. We take this idea a step further in allowing to only declare these predicates in JML without giving an explicit definition. The explicit definition is done directly in the language to which the Java program and the specifications are translated. To this end we introduce a new keyword to JML, the keyword native. To facilitate these definitions we have enabled the user to define also native types in the same way. In this paper we will describe these new constructs as well as their implementation in Jack, and their application to JML's libraries and model fields.

View PDFchevron_right
JML’s Rich, Inherited Specifications for Behavioral Subtypes
G. Leavens

Lecture Notes in Computer Science, 2006

The Java Modeling Language (JML) is used to specify detailed designs for Java classes and interfaces. It has a particularly rich set of features for specifying methods. This paper describes those features, with particular emphasis on the features related to specification inheritance. It shows how specification inheritance in JML forces behavioral subtyping, through a discussion of semantics and examples. It also describes a notion of modular reasoning based on static type information, supertype abstraction, which is made valid in JML by methodological restrictions on invariants, history constraints, and initially clauses and by behavioral subtyping.

View PDFchevron_right
Extending JML for Modular Specification and Verification of Multi-threaded Programs
Edwin Rodriguez

European Conference on Object-Oriented Programming, 2005

The Java Modeling Language (JML) is a formal specification language for Java that allows developers to specify rich software contracts for interfaces and classes, using pre- and postconditions and invariants. Although JML has been widely studied and has robust tool support based on a variety of automated verification technologies, it shares a problem with many similar object-oriented specification languages—it currently only deals with sequential programs. In this paper, we extend JML to allow for effective specification of multi-threaded Java programs. The new constructs rely on the non-interference notion of method atomicity, and allow developers to specify locking and other non-interference properties of methods. Atomicity enables effective specification of method pre- and postconditions and supports Hoare-style modular reasoning about methods. Thus the new constructs mesh well with JML’s existing features. We validate the specification language design by specifying the behavior of a number of complex Java classes designed for use in multi-threaded programs. We also demonstrate that it is amenable to automated verification using model checking technology.

View PDFchevron_right

Related topics

  • Distributed Computing
  • Formal Specification
  • Java Modeling Language
    • 580 California St., Suite 400
    San Francisco, CA, 94104
    © 2025 Academia. All rights reserved