Results 1 
6 of
6
Discovering Algebraic Specifications from Java Classes
 In ECOOP
, 2003
"... We present and evaluate an automatic tool for extracting algebraic specifications from Java classes. Our tool maps a Java class to an algebraic signature and then uses the signature to generate a large number of terms. The tool evaluates these terms and based on the results of the evaluation, it pro ..."
Abstract

Cited by 76 (4 self)
 Add to MetaCart
We present and evaluate an automatic tool for extracting algebraic specifications from Java classes. Our tool maps a Java class to an algebraic signature and then uses the signature to generate a large number of terms. The tool evaluates these terms and based on the results of the evaluation, it proposes equations. Finally, the tool generalizes equations to axioms and eliminates many redundant axioms. Since our tool uses dynamic information, it is not guaranteed to be sound or complete. However, we manually inspected the axioms generated in our experiments and found them all to be correct.
A Tool for Writing and Debugging Algebraic Specifications
 Proceedings of the 26th International Conference on Software Engineering (ICSE 2004), IEEE Computer Society Press
, 2004
"... Despite their benefits, programmers rarely use formal specifications, because they are difficult to write and they require an up front investment in time. To address these issues, we present a tool that helps programmers write and debug algebraic specifications. Given an algebraic specification, our ..."
Abstract

Cited by 17 (2 self)
 Add to MetaCart
Despite their benefits, programmers rarely use formal specifications, because they are difficult to write and they require an up front investment in time. To address these issues, we present a tool that helps programmers write and debug algebraic specifications. Given an algebraic specification, our tool instantiates a prototype that can be used just like any regular Java class. The tool can also modify an existing application to use the prototype generated by the interpreter instead of a handcoded implementation. The tool improves the usability of algebraic specifications in the following ways: (i) A programmer can “run ” an algebraic specification to study its behavior. The tool reports in which way a specification is incomplete for a client application. (ii) The tool can check whether a specification and a handcoded implementation behave the same for a particular run of a client application. (iii) A prototype can be used when a handcoded implementation is not yet available. Two case studies demonstrate how to use the tool. 1.
Principles of Inverse Computation and the Universal Resolving Algorithm
 IN THE ESSENCE OF COMPUTATION: COMPLEXITY, ANALYSIS, TRANSFORMATION
, 2002
"... We survey fundamental concept in inverse programming and present the Universal Resolving Algorithm (URA), an algorithm for inverse computation in a firstorder, functional programming language. We discusst he principles behind the algorithm, including a threestep approach based on the notion of a p ..."
Abstract

Cited by 13 (2 self)
 Add to MetaCart
We survey fundamental concept in inverse programming and present the Universal Resolving Algorithm (URA), an algorithm for inverse computation in a firstorder, functional programming language. We discusst he principles behind the algorithm, including a threestep approach based on the notion of a perfect process tree, and demonstrate our implementation with several examples. We explaint he idea of a semantics modifier for inverse computation which allows us to perform inverse computation in other programming languages via interpreters.
Verification of Logic Programs and Imperative Programs
 Constructing Logic Programs
, 1993
"... This paper explores the relationship between verification of logic programs and imperative programs with the aim of uncovering the kinds of reasoning used to construct logic programs. We discuss forward reasoning, such as that used for verifying imperative programs using the inductive assertion meth ..."
Abstract

Cited by 5 (0 self)
 Add to MetaCart
This paper explores the relationship between verification of logic programs and imperative programs with the aim of uncovering the kinds of reasoning used to construct logic programs. We discuss forward reasoning, such as that used for verifying imperative programs using the inductive assertion method, and backward reasoning, such as that used for verifying imperative programs using subgoal induction and logic programs using consequence verification. We argue that consequence verification is often inadequate for Prolog programs because programmers make implicit assumptions about how procedures are called. These assumptions can be made explicit using general type declarations. Verification of logic programs with type declarations can be done in two steps. We show that one corresponds to subgoal induction and the other corresponds to the inductive assertion method. Thus two existing verification methods are combined. The forward and backward reasoning inherent in this method of verificat...
Discovering Algebraic Specifications for Java Classes
, 2004
"... Modern programs make extensive use of reusable software libraries. For example, a study of a number of large Java applications shows that between 17 % and 30 % of the classes in those applications use the container classes from the java.util package. Given this extensive code reuse in Java programs, ..."
Abstract
 Add to MetaCart
Modern programs make extensive use of reusable software libraries. For example, a study of a number of large Java applications shows that between 17 % and 30 % of the classes in those applications use the container classes from the java.util package. Given this extensive code reuse in Java programs, it is important for the reusable interfaces to have clear and unambiguous documentation. Unfortunately, most documentation is expressed in English, and therefore does not always satisfy the above requirements. Worse yet, there is no way of checking that the documentation is consistent with the associated code. Formal specifications, such as algebraic specifications, do not suffer from these problems; however, they are notoriously hard to write. To alleviate this difficulty we describe a tool that automatically derives documentation for interfaces of Java classes. Our tool probes Java classes by invoking them on dynamically generated tests and captures the information observed during their execution as algebraic axioms. While the tool is not complete or correct from a formal perspective we demonstrate that it significantly alleviates the task of writing formal documentation for reusable components. 1