Algorithms for Interface Synthesis

Abstract

A temporal interface for a software component is a finite automaton that specifies the legal sequences of calls to functions that are provided by the component. We compare and evaluate three different algorithms for automatically extracting temporal interfaces from program code: (1) a game algorithm that computes the interface as a representation of the most general environment strategy to avoid a safety violation; (2) a learning algorithm that repeatedly queries the program to construct the minimal interface automaton; and (3) a CEGAR algorithm that iteratively refines an abstract interface hypothesis by adding relevant program variables. For comparison purposes, we present and implement the three algorithms in a unifying formal setting. While the three algorithms compute the same output and have similar worst-case complexities, their actual running times may differ considerably for a given input program. On the theoretical side, we provide for each of the three algorithms a family of input programs on which that algorithm outperforms the two alternatives. On the practical side, we evaluate the three algorithms experimentally on a variety of Java libraries.

Learning Component Interfaces with May and Must Abstractions

“…However, the need has been identified for interfaces that document richer aspects of component behavior. For example in this work, as in others [1,5,8,11,12,16], interfaces describe correct sequences of invocations to public methods of a component. Richer interfaces can serve as a documentation aid to application programmers, but can also be used by verification tools in checking that the components are invoked correctly within a system.…”

“…We selected five methods as the alphabet Σ ={close, (connect,0), (connect,1), flush, write }, where we model invocations of connect method returning different values (0 or 1) as different methods ((connect,0) or (connect,1)) similar to the approach taken in [5]. The exception NullPointerException was modelled as the error predicate.…”

“…Extended interfaces can be difficult to characterize precisely without the help of automated tools, making interface generation an area of active research [1,5,16]. The approaches closest to ours are those presented in [1,16].…”

Process-based derivation of requirements for medical devices

“…For that extension, our approach builds on interface synthesis methods, e.g., [3,6,19]. These methods take as input a software component and a requirement of that component and output an interface that captures the most general way to use that component without violating the given requirement; conceptually, these methods are performing assumption generation where the system component is known but the particular environment in which that component is used is unknown.…”

“…Unlike the assumption generation methods, the interface synthesis algorithms do not stop when the first violation is found and thus the interfaces should be weak enough to be useful requirements. While some interface synthesis methods use a combination of learning and model checking, as in the assumption generation techniques, other interface synthesis methods have been developed that are based on game theory or counterexample guided abstraction refinement, e.g., [6,20]. In particular, the interface synthesis techniques employ different strategies to weaken the generated interfaces.…”