Using Global Analysis, Partial Specifications, and an Extensible Assertion Language for Program Validation and Debugging

Hermenegildo, Manuel V.; Puebla, Germán; Bueno, Francisco

doi:10.1007/978-3-642-60085-2_7

Cited by 54 publications

(101 citation statements)

References 26 publications

Supporting

Mentioning

100

Contrasting

Order By: Relevance

“…These schemes express what run-time library predicates are called and where such calls are placed. Figure 2 shows the schemes, whereas the run-time library predicates are described below 7 . checkc(C,F ): checks condition C and sets F to true or false depending on whether it succeeds or not.…”

Section: Transforming Single Predicate Assertionsmentioning

confidence: 99%

“…For example, the assertion: :-texec append(A, B, C): (A=X, B=Y, C=Z) + try_sols (7). expresses that the call to append(X, Y, Z) should be executed to get at most the first 7 solutions through backtracking.…”

Section: Defining Unit Testsmentioning

confidence: 99%

“…We present an approach that unifies unit testing with run-time verification within an overall framework that also comprises static verification and static debugging [3,7,11,12,8]. This novel framework for program development is aimed at finding bugs in programs or validating them with respect to (partial) specifications given in terms of assertions (using the concept of abstractions as over-/under-approximations of program semantics).…”

Section: Introductionmentioning

confidence: 99%

See 2 more Smart Citations

Integrating Software Testing and Run-Time Checking in an Assertion Verification Framework

2009

Self Cite

View full text Add to dashboard Cite

Abstract. We present a framework that unifies unit testing and runtime verification (as well as static verification and static debugging). A key contribution of our overall approach is that we preserve the use of a unified assertion language for all of these tasks. We first describe a method for compiling run-time checks for (parts of) assertions which cannot be verified at compile-time via program transformation. This transformation allows checking preconditions and postconditions, including conditional postconditions, properties at arbitrary program points, and certain computational properties. Most importantly, we propose a minimal addition to the assertion language which allows defining unit tests to be run in order to detect possible violations of the (partial) specifications expressed by the assertions. We have implemented the framework within the Ciao/CiaoPP system and effectively applied it to the verification of ISO Prolog compliance and to the detection of different types of bugs in the Ciao system source code. Experimental results are presented that illustrate different trade-offs among program size, running time, or levels of verbosity of the messages shown to the user.

show abstract

Section: Transforming Single Predicate Assertionsmentioning

confidence: 99%

Section: Defining Unit Testsmentioning

confidence: 99%

Section: Introductionmentioning

confidence: 99%

See 1 more Smart Citation

Integrating Software Testing and Run-Time Checking in an Assertion Verification Framework

2009

Self Cite

View full text Add to dashboard Cite

show abstract

“…Fortunately we carne up with a unique solution to this apparent conundrum: Ciao includes a very rich assertion language (and a methodology for dealing with such assertions) [52,82] which allows expressing not only classical types, but also a much wider variety of properties (modes, determinacy non-failure, cost, ...), but in Ciao these assertions are optíonal. This solution makes Ciao very useful both for programming in the small and in the large.…”

Section: The Ciao Approach To Assertionsmentioning

confidence: 99%

“…Another fundamental characteristic of the Ciao system is that it provides a powerful preprocessor, called CiaoPP [8,52,53], which is capable of statically ñnding non-trivial bugs, verifying that the program complies with speciñcations, and performing many types of program optimizations. A key ingredient for the above task is the Ciao assertion language [82].…”

mentioning

confidence: 99%

An Overview of the Ciao Multiparadigm Language and Program Development Environment and Its Design Philosophy

Hermenegildo¹,

Bueno²,

Carro³

et al. 2008

Concurrency, Graphs and Models

Self Cite

View full text Add to dashboard Cite

Abstract. We describe some of the novel aspects and motivations behind the design and implementation of the Ciao multiparadigm programming system. An important aspect of Ciao is that it provides the programmer with a large number of useful features from different programming paradigms and styles, and that the use of each of these features can be turned on and off at will for each program module. Thus, a given module may be using e.g. higher order functions and constraints, while another module may be using objects, predicates, and concurrency. Furthermore, the language is designed to be extensible in a simple and modular way. Another important aspect of Ciao is its programming environment, which provides a powerful preprocessor (with an associated assertion language) capable of statically finding non-trivial bugs, verifying that programs comply with specifications, and performing many types of program optimizations. Such optimizations produce code that is highly competitive with other dynamic languages or, when the highest levéis of optimization are used, even that of static languages, all while retaining the interactive development environment of a dynamic language. The environment also includes a powerful auto-documenter. The paper provides an informal overview of the language and program development environment. It aims at illustrating the design philosophy rather than at being exhaustive, which would be impossible in the format of a paper, pointing instead to the existing literature on the system.

show abstract

Annotations for Prolog – A Concept and Runtime Handling

Kulas

2000

Logic-Based Program Synthesis and Transformation

View full text Add to dashboard Cite

Abstract. A concept of annotations for rendering procedural aspects of Prolog is presented, built around wellknown procedural concepts of Standard Prolog. Annotations describe properties of predicates. Such properties can be pre or post conditions, which must hold true when a predicate is called or exited, respectively. Our concept transcends pre/post conditions: we introduce two more kinds of annotations, fail and redo annotations, hence incorporating a whole model of Prolog execution into our language. This enables natural rendering of many procedural properties of Prolog which cannot be expressed with only pre/post conditions. There are four more novelties in our approach. First, any annotation can be "narrowed down" to a subset of calls, via templates and contexts, giving much more flexible assertions. Notably the novel idea of calling context adds significant expressive power, as a bridge towards program-point assertions. The annotations are defined simply as Prolog goals, making them fully parametric and therefore very comfortable for debugging. Finally, the annotations are applied via a general kind of matching instead of unification, enabling the use of local variables. All examples presented here are actual runs of our system Nope, which is a Prolog module.

show abstract

Using Global Analysis, Partial Specifications, and an Extensible Assertion Language for Program Validation and Debugging

Cited by 54 publications

References 26 publications

Integrating Software Testing and Run-Time Checking in an Assertion Verification Framework

Integrating Software Testing and Run-Time Checking in an Assertion Verification Framework

An Overview of the Ciao Multiparadigm Language and Program Development Environment and Its Design Philosophy

Annotations for Prolog – A Concept and Runtime Handling

Contact Info

Product

Resources

About