Compiler and tool support for debugging object protocols

Abstract

We describe an extension to the Java programming language that supports static conformance checking and dynamic debugging of object "protocols," i.e., sequencing constraints on the order in which methods may be called. Our Java protocols have a statically checkable subset embedded in richer descriptions that can be checked at run time. The statically checkable subtype conformance relation is based on Nierstrasz' proposal for regular (finite-state) process types, and is also very close to the conformance relation for architectural connectors in the Wright architectural description language by Allen and Garlan. Richer sequencing properties, which cannot be expressed by regular types alone, can be specified and checked at run time by associating predicates with object states. We describe the language extensions and their rationale, and the design of tool support for static and dynamic checking and debugging.

Typestate protocol specification in JML

“…Our design builds on that of Bierhoff & Aldrich. Butkevich et al describe protocols as labeled transition systems, check dynamically for protocol usage violations, and can statically check for hierarchy violations [10]. Barnett, Rustan, Leino and Schulte introduce Spec# [14], a formal language for API contracts similar to JML and Eiffel [11].…”

Lightweight object specification with typestates

“…They can express non-determinism and case-by-case behavior, increasing expressiveness and precision over specifications in Fugue. An alternative approach by Butkevich et al uses labelled transition systems to specify protocols with non-determinism that can be checked statically for hierarchy violations [2].…”

“…This happens if the pre-condition is strengthened or the post-condition is weakened. Butkevich et al can detect hierarchy violations statically for their protocols [2]. Pre-and post-condition systems in general cannot detect hierarchy violations statically.…”

“…One of the most important applications of Fugue was to find dangling resource bugs such as files and SQL connections that were not properly closed [6]. Just like Fugue, Butkevich et al mark valid end states and check that they are reached [2]. We suggest an alternative approach that works better in the presence of state refinements.…”

“…Fugue contributes in many ways to this paper. In an alternative approach, Butkevich et al describe protocols as labelled transition systems and can statically check for hierarchy violations [2]. They have no analogue to state refinement or dimensions.…”