Initial steps towards assessing the usability of a verification tool

TL;DR

This paper discusses the initial experience of using AutoProof for static verification of an object-oriented program, highlighting challenges and proposing improvements to enhance usability and methodology.

Contribution

It provides an analysis of usability issues encountered with AutoProof and suggests modifications to improve the verification process for users.

Findings

Identified key tool-related problems affecting verification

Classified issues into tool and methodology categories

Proposed changes to simplify verification workflow

Abstract

In this paper we report the experience of using AutoProof to statically verify a small object oriented program. We identified the problems that emerged by this activity and we classified them according to their nature. In particular, we distinguish between tool-related and methodology-related issues, and propose necessary changes to simplify both tool and method.

Figures

Equations

$$\begin{array}[]{l}{\bf create}~{}\textsf{make}\\ {\bf feature{}}\\ \hskip 5.69046pt\textsf{make}\\ \hskip 11.38092pt{\bf note}\\ \hskip 22.76228pt{\texttt{status: }}\textsf{creator}\\ \hskip 11.38092pt{\bf do}~{}\textsf{\dots}~{}{\bf end}\\ \end{array}$$

$$\begin{array}[]{l}{\bf invariant{}}\\ \hskip 11.38092pt{\bf model\_def:elements=data.sequence.range}\\ \hskip 11.38092pt{\bf owns\_def:owns=[data]}\\ \hskip 22.76228pt\textsf{\dots}\\ \end{array}$$

$$\begin{array}[]{l}{\bf feature}~{}{-}{-}\textsf{ Queries}\\ \hskip 8.5359pt\textsf{union}(\textsf{other}:{\bf like~{}Current}):{\bf like~{}Current}\\ \hskip 17.07182pt{-}{-}\textsf{ New set of values contained in `Current' or `other'}\\ \hskip 11.38092pt{\bf note}~{}\textsf{status}:\textsf{impure}\\ \hskip 11.38092pt{\bf require}\\ \hskip 17.07182pt\textsf{ modify\_nothing }:\textsf{ modify([ ])}\\ \hskip 22.76228pt\textsf{\ldots}\\ \hskip 11.38092pt{\bf end}\end{array}$$

Full text

1 Introduction

Formal proof of correctness of software is still not commonly accepted in practice, even though both hardware and software technologies for verification have significantly improved since it was first mentioned in the context of ”verifying compiler”111A cipher for an integrated set of tools checking correctness in a broad sense [1, 2]. In ideal world verifying software would need only “pushing a button”, though this kind of provers exist, but they are limited to verification of simple or implicit properties such as absence of invalid pointer dereference [3]. In order to verify a software, a formal specification should be provided against which it will be verified. Given a specification, like contracts in Design-by-Contract (DbC) methodology, it is possible to verify specific implementations with respect to this specification. The term Design-by-Contract was originally introduced in connection with the design of the Eiffel programming language, but is nowadays also adopted in many other languages. For example, in C# the methodology is supported through an additional library [4]. Java has JML add-on [5], while Kotlin has preconditions (require and requireNotNull clauses) implemented at the language level. Contracts are fully supported in Eiffel.

Eiffel has a prover for functional correctness called AutoProof [6]. This prover comes with a powerful methodology for framing and class invariants and it fully supports advanced object-oriented features [7]. We here present a series of case studies in order to test the usability of the tool and its applicability in general practice . The tool was used for verification of three exercises of different size and complexity: a simple class, a set of related classes and small size industrial project. This paper describes the results of the first exercise - verification of the class SET, that implements classic sets from set theory: properties and classical operations.

The challenge of this exercise is mainly related to difficulties that a new user can encounter while using the tool for the first time. There is no explicit documentation available: only the website and several papers from the authors of the tool as the main source of information. However the notation has been evolving and in some of these papers it is no longer relevant. Verification with AutoProof often requires additional annotation that helps the tool to derive the more “complex” properties from the trivial ones. However, for someone who does not know how the tool works and what is going on under the hood, the feedback from the tool can be useless or even confusing. Naturally, this might be excusable if the tool is meant to be used by a limited group of scientists, but complete documentation needs to be developed, thereby minimizing the need of additional assertions, in order to make a verification tool applicable in industrial practice. This is essential, because the tool still requires a knowledge of the underlying mechanisms and a number of additional annotations.

2 Eiffel and Autoproof

Eiffel is an object oriented programming language that natively supports the Design-by-Contract methodology [6]. All features in Eiffel should be specified through equipping them with contracts, namely pre- and post-conditions; as well as properties of classes through invariants. AutoProof is a static verifier for programs written in Eiffel. It follows the auto-active paradigm[6] where verification is done completely automated, similar to model checking [3], but where users are expected to feed the classes providing additional information in the form of annotations to help the proof. The tool is capable of identifying software issues without executing the code, thereby opening a new frontier for “static debugging”, software verification and reliability in addition to general improvements to software quality.

AutoProof verifies the functional correctness of a code written in Eiffel language equipped with contracts. The tool checks that routines satisfy pre- and post-conditions, maintenance of class invariants, loops and recursive calls termination, integer overflow and non Void (i.e. $null$ in many other programming languages) references calls. For that purpose, AutoProof uses a verification language called Boogie [8]: AutoProof translates Eiffel code into Boogie programs as an intermediary step. The Boogie tool generates verification conditions (logic formulas whose validity entails the correctness of the input programs) that are then passed to an SMT solver Z3. Finally, the verification output is returned to Eiffel.

AutoProof supports most of the Eiffel language constructs: in-lined assertions such as check ($assert$ in many other programming languages), types, multi-inheritance, polymorphism. By default AutoProof only verifies user-written classes when a program is verified, while referenced libraries should be verified separately or should be based on pre-verified libraries, e.g. EiffelBase2 [9]. This pre-verified library offers many different data structures with all features fully verified.

3 Case study experience

The first stage in series of case studies was verification of simple example – the implementation of an ordinary class for a generic implementation of sets, MY_SET, using lists ( V_LINKED_LIST from the EiffelBase2 library) and equipping it with contracts. Corresponding annotations were added to help AutoProof to prove the class.

Set properties were expressed as invariants, namely:

• •

No duplicate elements

• •

Order of elements in the set is not important

• •

Cardinality is always greater or equal to 0

The class implements some basic set operations:

• •

is_empty - a query that states whether the set contain no elements

• •

cardinality - number of elements in the set

• •

has - a query that states whether the set contains a given element

• •

is_strict_subset, is_ subset - queries that states whether the set is a subset (or a strict subset) of a given set

• •

union, intersection, difference - functions returning new set with the union, intersection of difference with a given set, respectively

During the verification process, it turned out, that working with V_ classes was too complicated for non-expert users. Therefore the decision was done to simplify the example replacing V_LINKED_LIST with SIMPLE_LIST.

4 Problems taxonomy

Despite the simplicity of the class, various problems arose due to lack of user experience with the AutoProof tool, ranging from issues with the tool installation all the way to issues with checking the verified class with tests. In our analysis, these problems have been divided into two main categories: problems with the tool and problems with the approaches or methodologies used in the tool.

Problems with the tool

1. (a)

Lack of documentation 2. (b)

Poor tool feedback 3. (c)

Redundancy in notations 4. (d)

Misleading notations 5. (e)

Order of assertions 6. (f)

Limitations of the tool 7. (g)

User Interface (UI) bug 8. (h)

Difficulties with installation/compilation from the sources 2. 2.

Problems with methodologies

1. (a)

Semantic collaboration 2. (b)

Framing

The first category includes rather minor problems and bugs, mostly related to the particular implementation in the tool and means that those require local fixes. However, the second category require improving the methodology or replacing them with the alternative ones.

4.1 Problems with the tool

The challenge of this exercise was mainly related to the fact that it had to be done by a person who has no previous experience with AutoProof, nor any other similar tools. The difficulty is not in some sophisticated user interface (UI), quite the opposite, it is rather simple (see figure 1) - a “Verify” button and a table, where the results are being displayed. The main obstacle is in the fact that, the tool expects an input in terms of assertions, and it is not always clear what the real effect of each input is.

4.1.1 Lack of documentation

As we previously described, the tool requires additional annotations that assist the verification and help to derive one property from another. Although AutoProof exploits the syntax of the Eiffel language, additional annotations have been introduced by the developers of the tool. Most of them are briefly described in the online manual, which is available on the EVE website222EVE (Eiffel Verification Environment). EVE is a development environment integrating formal verification with the standard tools. In addition, there is an online tutorial which is useful for quick acquaintance with the tool. However, this is clearly an insufficient reference material for working with the tool.

Overall, there is not much of documentation available online: the website, and several papers from the authors of the AutoProof tool.Moreover, the notation has been evolving and in some of these papers it is no longer relevant.Naturally, this might be excusable if the tool is meant to be used by a limited group of scientists. On the other hand, if the idea is to apply verification in industrial practices, then documentation is essential. The tool still requires documentation that explains the annotations needed and the knowledge of the different mechanisms.

4.1.2 Poor tool feedback

The process verification (or static debugging) starts with pushing a “Verify” button. The tool then returns some feedback in the form of success, error and failure messages. A failure message is a message that shows the property that cannot be proved. An error message consists of information on some issue with the input. In both case, whether it is error or failure messages, users need to fix them by adding missing assertions. This process repeats until the class is fully verified. AutoProof implements a collection of heuristics known as “two-step verification” that helps discern between failed verification due to real errors and failures due to insufficiently detailed annotations [6]. These failure messages are usually informative: they describe the property and sometimes the reason of the failure. On the other hand, error messages usually do not tell more than that the tool cannot proceed with the input it has received.

If there is an error during the translation to Boogie the verification process stops and AutoProof returns an error message about “internal failure” in some cases with no additional information. Usually, this errors are caused by newly entered assertions, which makes the process of correcting them easier. However, if this is not the case, then it is difficult to understand what exactly causes the error. This may become an issue when verifying the whole class, with all its implemented features and stated contracts, because it is not possible to determine the source of the error. The solution might be to comment out the features and iteratively verify them one by one by decommenting them.

4.1.3 Redundancy in annotations

AutoProof supports most of the Eiffel language as used in practice [6]. It also introduces some new notations that support the methodologies used for verification. These notations are useful for manipulating the defaults of semantic collaboration in features and classes (this will be discussed in 4.2.1).

However, some of these additional notations introduce redundancy. For example all creation procedures in Eiffel must be listed under the key word create. Autoproof does not make use of this and instead expects the user to explicitly declare the creation procedure as depicted in Figure 2. Even though the procedure make is defined as a creation procedure in Eiffel, the verifier expects an additional note clause with status: creator in order to treat it as creation procedure.

Another example is the possible inconsistencies on the given annotations. In Autoproof, one can declare a procedure as pure, specifying that it will not change the state of the object, or impure specifying that the procedure might change the state. This can also be achieved by listing the locations that the procedure might change. This is done by using the annotation modify. If the clause is empty it means that the function is pure, impure otherwise. For Autoproof to be able to prove the procedure union in Figure 4, it has to be defined with the impure annotation. This means that it does modify the state of the object. The empty clause modify then needs to specify that the function is pure. This is done in order to be able to use wrap and unwrap in the function (as explained later on).

4.1.4 Misleading notations

AutoProof support inline assertions and assumptions, which can be expressed using the check clause supported by Eiffel. Checks are intermediate assertions that are used during the debugging process in order to check whether the user has the same understanding of the state at a program point as the verifier [10]. However, removing an intermediate check clause from successfully verified feature might make the verification process fail. This, more than being there for the user, is due to check assertions and guides the verifier towards a successful verification. Probably this is a design solution: not to introduce another clause but to use an existing one from the language. However, this might confuse users.

4.1.5 Order of assertions

A check clause is useful because the verifier does not just check the property enclosed, but also uses it for further derivations in case the property was proved correct. The same applies to class invariants, and that makes the order of properties substantial for the tool. This means that properties are joint not by the and operator, but by and then, which may lead to verification failures even if all needed properties are stated (although in improper order). For example, there are two assertions depicted in figure 3: the first for setting up the relation between elements (the model) and data (the implementation); the second, for defining owned object by Current333denoting the current object in Eiffel. However, in this order the verification will fail, while it will succeed if owns_def is stated first.

4.1.6 Limitations of the tool

Null pointer dereferencing is a well-known issue in object-oriented programming. In Eiffel, this can be avoided by letting the compiler check for call consistency [11]: the object source making the call cannot be a Void object. Currently, Autoproof does not make use of this property of Eiffel. For instance the verified library EiffelBase2 can only be used when the void-safety property of Eiffel is disabled. There is a coming version of the tool to support these two Eiffel environments, but the version is not available yet.

4.1.7 User Interface (UI) bug

The tool lacks support which can be observed in some rare bugs. For example, it can skip some of the features of the class or verify only one of the features instead of the whole class. Even though, the tool never returned improper successful verification results, these kinds of bugs might be disrupting to the user.

4.1.8 Difficulties with installation/compilation from sources

There are two ways to get the tool working on a local computer: by installing the build (available online) or compiling the tool from the source code. For the latter option, the repository requires a clean-up for compiling. Therefore, is better to use the former method.

In addition, there are several manipulation has to be done while creating a new project in AutoProof, such as disabling some options and reopening the project in order to clean it.

4.2 Problems with methodology: Semantic collaboration and Framing

AutoProof supports advanced object-oriented features through a powerful methodology to specify and reason about class invariants of sequential programs [7]. But this power comes at the price of simplicity - the tool requires users to understand all the underlying methodologies. This limits the tool to expert users by exceedingly complicating the verification of even such simple classes.

4.2.1 Semantic collaboration

AutoProof supports semantic collaboration, i.e. the full-fledged framing methodology that was designed to reason about class invariants of structures made of collaborating objects [7]. This methodology introduces its own annotations which do not exist in the Eiffel language. Annotations are used to equip features and entire classes with additional information which are used by the verifier. These include ghost attributes – class members used only in specifications – which are useful when maintenance of global consistency is required as in subject/observer or iterator pattern examples [7]. These ghost attributes and default assertions that are added into pre- and post-conditions often result in over-complicating the verification process of rather simple classes.

During initial steps of the verification process of the case study presented in this paper, time was spent on trying to understand the failure message: “default_is_closed may be violated on calling some feature” for some private attribute. Basically, the tool was expecting owns = [data] in the invariants of the class which is not obvious without understanding the methodology. Moreover, for this specific example the property could have been derived from exportation status of the attribute. Eiffel language supports the notion of “selective export”, which exports the features that follow to the specific classes and their descendants [12]. The verifier ignores this useful information and requires the properties to be stated explicitly. Considering selective export might decrease the need for using semantic collaboration [13].

4.2.2 Framing

The framing model is used in AutoProof in order to help reason about objects that are allowed/not allowed to be updated. There are different ways to specify this, for instance by adding modifies clauses in pre-conditions. One can specify one or more model fields, attributes of the class or list of objects which may be updated. This is rather intuitive and straightforward, though it seems to be more relevant to post-condition clauses. Another alternative is to make use of default clauses included into each routine, so the framing model should be used only if the behavior of the routines is different than from default. For example, in MY_SET class, all routines are pure (no side effects), hence all routines were equipped with an empty modify clause. Even in a function that is defined as pure using the modify clause, that function needs to be specified as impure in order to use is_wrapped clause, even though it does not modify the state of any object (see figure 4). This might confuse the user.

5 Related Work

Formal notations to specify and verify software systems have existed for a long time, in particular in some specific domain such as process modeling [14]. A survey of the major approaches can be found in [15], while [16] discusses the most common methodological issues of such approaches. Another approach, as in [17, 18], is to use the formal notation of a modeling language to specify and verify software systems to then translate it to a programming language.

In [19] the authors present an extensive survey of algorithms for automatic static analysis of software. The discussed techniques (static analysis with abstract domains, model checking, and bounded model checking) are different, but complementary, to the one discussed in this paper, and they are also able to detect programming errors or prove their absence.

The importance of focusing on usability requirements for verification tools has been identified in [20]. The authors have classified usability properties into three main categories: Interface, Utility and Resources management. Since the interface of AutoProof tool consists of a button and a table, the interface category was omitted. Only utility (in term of clearness of error/failure messages) and Resources management (in term of properties such as installation, documentation) were considered.

The results of testing the usability of AutoProof, in particular, by non-expert users has been studied in [21], where programmers with little formal methods experience were exposed to the tool.

6 Conclusion

AutoProof is not trivial in its usage and needs detailed knowledge of what is going on behind the scenes. The tool requires a number of additional assertions in pre- and post-conditions, as well as in invariants for successful verification, while ignoring some information that has been already provided. To be used in practice the usability of the tools needs to be be significantly improved to the level where verification is “simple” enough to be used by ordinary programmers. By “simple” we mean, that it should:

• •

require less additional annotations by automatically deriving properties from information which is currently being neglected and by removing redundant clauses and reworking some of ghost class members;

• •

provide clearer feedback in case some property can not be satisfied, offering hints and possible solutions;

In addition, it is important to:

• •

develop a documentation describing all used methodologies, including detailed information about notations with examples

• •

clean up and rebuild the tool from latest sourced that are available in the EVE repository and fix all the bugs that we identified;

As a further work, AutoProof will be tested through verification of a set of related classes and a small size industrial project, the Tokeneer project444http://www.adacore.com/sparkpro/tokeneer/download.