Declarative Debugging Research Articles

A unified framework for declarative debugging and testing

Abstract Context: Debugging is the most challenging and time consuming task in software development. However, it is not properly integrated in the software development cycle, because the result of so much effort is not available in further iterations of the cycle, and the debugging process itself does not benefit from the outcome of other phases such as testing. Objective: We propose to integrate debugging and testing within a single unified framework where each phase generates useful information for the other and the outcomes of each phase are reused. Method: We consider a declarative debugging setting that employs tests to automatically entail the validity of some subcomputations, thus decreasing the time and effort needed to find a bug. Additionally, the debugger stores as new tests the information collected from the user during the debugging phase. This information becomes part of the program test suite, and can be used in future debugging sessions, and also as regression tests. Results: We define a general framework where declarative debugging establishes a bidirectional collaboration with testing. The new setting preserves the properties of the underlying declarative debugging framework (weak completeness and soundness) while generating test cases that can be used later in other debugging sessions or even in other cycles of the software development. The proposed framework is general enough to be instantiated to very different programming languages: Erlang (functional), Java (imperative, object-oriented), and SQL (data query); and the experimental results obtained for Erlang programs validate the effectiveness of the framework. Conclusion: We propose a general unified framework for debugging and testing that simplifies each phase and maximizes the reusability of the outcomes in the different phases of the software development cycle, therefore reducing the overall effort.

A core Erlang semantics for declarative debugging

One of the main advantages of declarative languages is their clearly established formal semantics, that allows programmers to reason about the properties of programs and to establish the correctness of tools. In particular, declarative debugging is a technique that analyses the proof trees of computations to locate bugs in programs. However, in the case of commercial declarative languages such as the functional language Erlang, sometimes the semantics is only informally defined, and this precludes these possibilities. Moreover, defining semantics for these languages is far from trivial because they include complex features needed in real applications, such as concurrency. In this paper we define a semantics for Core Erlang, the intermediate language underlying Erlang programs. We focus on the problem of concurrency and show how a medium-sized-step calculus, that avoids the details of small-step semantics but still captures the most common program errors, can be used to define an algorithmic debugger that is sound and complete.

Declarative debugging of concurrent Erlang programs

Despite the growing number of concurrent applications in nowadays systems, debugging concurrent programs remains an open issue due to its intrinsic complexity. In this work, we present a declarative debugger for the concurrent language Erlang. Following the ideas of algorithmic debugging, our tool asks questions to the user about the validity of transitions between those program points that involve message passing, and also about the expected results of the function calls occurred during the computation. The differences between the user answers, which represent the intended behavior of the program, and the actual program execution, allow the debugger to detect the function responsible for the error, and to point out the pieces of source code responsible for the bugs. The proposal is based on a concurrent calculus for Erlang programs, and we show a benchmark that assesses its scalability both in terms of resources usage and considering the number of questions asked to the user and their complexity. Furthermore, we check the usability of our proposal, applying the debugger to the Erlang library poolboy.

Truth versus information in logic programming

AbstractThe semantics of logic programs was originally described in terms of two-valued logic. Soon, however, it was realised that three-valued logic had some natural advantages, as it provides distinct values not only for truth and falsehood but also for “undefined”. The three-valued semantics proposed by Fitting (Fitting, M. 1985. A Kripke–Kleene semantics for logic programs.Journal of Logic Programming 2, 4, 295–312) and Kunen (Kunen, K. 1987. Negation in logic programming.Journal of Logic Programming 4, 4, 289–308) are closely related to what is computed by a logic program, the third truth value being associated with non-termination. A different three-valued semantics, proposed by Naish, shared much with those of Fitting and Kunen but incorporated allowances for programmer intent, the third truth value being associated with underspecification. Naish used an (apparently) novel “arrow” operator to relate the intended meaning of left and right sides of predicate definitions. In this paper we suggest that the additional truth values of Fitting/Kunen and Naish are best viewed as duals. We use Belnap's four-valued logic (Belnap, N. D. 1977. A useful four-valued logic. InModern Uses of Multiple-Valued Logic, J. M. Dunn and G. Epstein, Eds. D. Reidel, Dordrecht, Netherlands, 8–37), also used elsewhere by Fitting, to unify the two three-valued approaches. The truth values are arranged in a bilattice, which supports the classical ordering on truth values as well as the “information ordering”. We note that the “arrow” operator of Naish (and our four-valued extension) is essentially the information ordering, whereas the classical arrow denotes the truth ordering. This allows us to shed new light on many aspects of logic programming, including program analysis, type and mode systems, declarative debugging and the relationships between specifications and programs, and successive execution states of a program.

Declarative debugging of rewriting logic specifications

Declarative debugging is a semi-automatic technique that starts from an incorrect computation and locates a program fragment responsible for the error by building a tree representing this computation and guiding the user through it to find the error. Membership equational logic (MEL) is an equational logic that in addition to equations allows one to state membership axioms characterizing the elements of a sort. Rewriting logic is a logic of change that extends MEL by adding rewrite rules, which correspond to transitions between states and can be nondeterministic. We propose here a calculus to infer reductions, sort inferences, normal forms, and least sorts with the equational subset of rewriting logic, and rewrites and sets of reachable terms through rules. We use an abbreviation of the proof trees computed with this calculus to build appropriate debugging trees for both wrong (an incorrect result obtained from an initial result) and missing answers (results that are erroneous because they are incomplete), whose adequacy for debugging is proved. Using these trees we have implemented Maude DDebugger, a declarative debugger for Maude, a high-performance system based on rewriting logic. We illustrate its use with an example.

An integrated framework for the diagnosis and correction of rule-based programs

We present a generic scheme for the declarative debugging of programs that are written in rewriting-based languages that are equipped with narrowing. Our aim is to provide an integrated development environment in which it is possible to debug a program and then correct it automatically. Our methodology is based on the combination (in a single framework) of a semantics-based diagnoser that identifies those parts of the code that contain errors and an inductive learner that tries to repair them, once the bugs have been located in the program. We develop our methodology in several steps. First, we associate with our programs a semantics that is based on a (continuous) immediate consequence operator, T R , which models the answers computed by narrowing and is parametric w.r.t. the evaluation strategy, which can be eager or lazy. Then, we show that, given the intended specification of a program R , it is possible to check the correctness of R by a single step of T R . In order to develop an effective debugging method, we approximate the computed answers semantics of R and derive a finitely terminating bottom-up abstract diagnosis method, which can be used statically. Finally, a bug-correction program synthesis methodology attempts to correct the erroneous components of the wrong code. We propose a hybrid, top-down (unfolding-based) as well as bottom-up (induction-based), correction approach that is driven by a set of evidence examples which are automatically produced as an outcome by the diagnoser. The resulting program is proven to be correct and complete w.r.t. the considered example sets. Our debugging framework does not require the user to provide error symptoms in advance or to answer difficult questions concerning program correctness. An implementation of our debugging system has been undertaken which demonstrates the workability of our approach.

A Declarative Debugger for Maude Functional Modules

A declarative debugger for Maude functional modules, which correspond to executable specifications in membership equational logic, is presented. Starting from an incorrect computation, declarative debugging builds a debugging tree as a logical representation of the computation, that then is traversed by asking questions to an external oracle until the error is found. We summarize the construction of appropriate debugging trees for oriented equational and membership inferences, where all the nodes whose correctness does not need any justification have been collapsed. The reflective features of Maude allow us to generate and navigate the debugging tree of a Maude computation using operations in Maude itself; even the user interface of the declarative debugger can be specified in this way. We present the debugger's main features, such as two different strategies to traverse the debugging tree, use of a correct module to reduce the number of questions asked to the user, selection of trusted vs. suspicious statements by means of labels, and trusting of statements ''on the fly.''

Declarative Debugging Meets the World

Declarative debugging has been proposed as a suitable technique for diagnosing errors. It is particularly attractive for declarative programming languages, whose operational semantics differs substantially from their declarative semantics. Declarative debuggers are usually described and implemented by means of a program transformation. However, this transformation does not mix well with monadic I/O, which is used by lazy functional and functional logic languages. Therefore, declarative debuggers for such languages either do not support debugging of programs involving stateful computations at all, or require special support from the compiler and its runtime system. In this paper, we present a modified program transformation that blends nicely with monadic I/O and therefore covers the whole language without additional support from the target implementation.

Lazy call-by-value evaluation

Designing debugging tools for lazy functional programming languages is a complex task which is often solved by expensive tracing of lazy computations. We present a new approach in which the information collected as a trace is reduced considerably (kilobytes instead of megabytes). The idea is to collect a kind of step information for a call-by-value interpreter, which can then efficiently reconstruct the computation for debugging/viewing tools, like declarative debugging. We show the correctness of the approach, discuss a proof-of-concept implementation with a declarative debugger as back end and present some benchmarks comparing our new approach with the Haskell debugger Hat.

A Framework for Interpreting Traces of Functional Logic Computations

This paper is part of a comprehensive approach to debugging for functional logic languages. The basic idea of the whole project is to trace the execution of functional logic programs by side effects and then give different views on the recorded data. In this way well known debugging techniques like declarative debugging, expression observation, redex trailing but also step-by-step debuggers and cost center oriented symbolic profiling can be implemented as special views on the recorded data. In addition, creating new views for special debugging purposes should be easy to implement. This is where the contribution of this work sets in. We describe how the recorded data is interpreted and preprocessed in order to yield an extremely simple yet versatile interface to base the different views on. Using this interface, formulating the basic functionality of declarative debugging, for example, is a matter of a few lines.

A three-valued semantics for logic programmers

This paper describes a simpler way for programmers to reason about the correctness of their code. The study of semantics of logic programs has shown strong links between the model theoretic semantics (truth and falsity of atoms in the programmer's interpretation of a program), procedural semantics (for example, SLD resolution) and fixpoint semantics (which is useful for program analysis and alternative execution mechanisms). Most of this work assumes that intended interpretations are two-valued: a ground atom is true (and should succeed according to the procedural semantics) or false (and should not succeed). In reality, intended interpretations are less precise. Programmers consider that some atoms “should not occur” or are “ill-typed” or “inadmissible”. Programmers don't know and don't care whether such atoms succeed. In this paper we propose a three-valued semantics for (essentially) pure Prolog programs with (ground) negation as failure which reflects this. The semantics of Fitting is similar but only associates the third truth value with non-termination. We provide tools to reason about correctness of programs without the need for unnatural precision or undue restrictions on programming style. As well as theoretical results, we provide a programmer-oriented synopsis. This work has come out of work on declarative debugging, where it has been recognised that inadmissible calls are important.

Declarative Debugging for Encapsulated Search

Declarative debugging has been proposed as a suitable technique for developing debuggers in the context of declarative languages. However, to become really useful debuggers must be able to deal with those parts of the languages that have no clear declarative semantics but are widely used in realistic programs. We explain in this paper how a declarative debugger of wrong answers for the lazy functional-logic language Curry can be extended to debug programs including the encapsulated search, an important feature of this language designed to control non-deterministic computation steps. We show how this can be done without introducing any changes in the compiler.

A Declarative Debugging System for Lazy Functional Logic Programs

We present a declarative debugger for lazy functional logic programs with polymorphic type discipline. Whenever a 0computed answer is considered wrong by the user (error symptom), the debugger locates a program fragment (function defining rule) responsible for the error. The notions of symptom and error have a declarative meaning w.r.t. to an intended program semantics. Debugging is performed by searching in a computation tree which is a logical representation of the computation. Following a known technique, our tool is based on a program transformation: transformed programs return computation trees along with the results expected by source programs. Our transformation is provably correct w.r.t. well-typing and program semantics. As additional improvements w.r.t. related approaches, we solve a previously open problem concerning the use of curried functions, and we provide a correct method for avoiding redundant questions to the user during debugging. A prototype implementation of the debugger is available. Case studies and extensions are planned as future work.

A Debugging Scheme for Functional Logic Programs

We present a generic scheme for the declarative debugging of functional logic programs which is valid for eager as well as lazy programs. In particular we show that the framework extends naturally some previous work and applies to the most modern lazy strategies, such as needed narrowing. First we associate to our programs a semantics based on a (continuous) immediate consequence operator, TR , which models computed answers. We show that, given the intended specification of a program R , it is possible to check the correctness of R by a single step of TR . We consider then a more effective methodology which is based on abstract interpretation: by approximating the intended specification of the success set we derive a finitely terminating diagnosis method, which can be used statically and is parametric w.r.t. to the chosen approximation. In order to correct the bugs, we sketch a preliminary deductive approach which uses example-guided unfolding. We specialize the incorrect rules w.r.t. sets of positive and negative examples which are gathered (bottom-up) during the diagnosis process, so that all refutations of negative examples and no refutation of positive examples are excluded. Our debugging framework does not require the user to either provide error symptoms in advance or answer difficult questions concerning program correctness. We extend an implementation of our system to the case of needed narrowing and illustrate it through some examples which demonstrate the practicality of our approach.

Declarative Debugging of Functional Logic Programs

We present a general framework for the declarative debugging of functional logic programs, which is valid both for eager as well as lazy programs. We associate to our programs a semantics based on a (continuous) immediate consequence operator which models computed answers. Then we show that, given the intended specification of a program P, it is possible to check the correctness of P by a single step of the immediate consequence operator.We also present a more effective methodology which is based on abstract interpretation. By approximating the intended specification of the success set we derive a finitely terminating debugging method, which can be used statically. Our framework is parametric w.r.t. to the chosen approximation of the success set. We present one specific example of approximation. We provide an implementation of our debugging system which shows experimentally on a wide set of benchmarks that we are able to find some common errors in the user programs.

New guidebook for transcultural care

Debugging is the most challenging and time consuming task in software development. However, it is not properly integrated in the software development cycle, because the result of so much effort is not available in further iterations of the cycle, and the debugging process itself does not benefit from the outcome of other phases such as testing.We propose to integrate debugging and testing within a single unified framework where each phase generates useful information for the other and the outcomes of each phase are reused.We consider a declarative debugging setting that employs tests to automatically entail the validity of some subcomputations, thus decreasing the time and effort needed to find a bug. Additionally, the debugger stores as new tests the information collected from the user during the debugging phase. This information becomes part of the program test suite, and can be used in future debugging sessions, and also as regression tests.We define a general framework where declarative debugging establishes a bidirectional collaboration with testing. The new setting preserves the properties of the underlying declarative debugging framework (weak completeness and soundness) while generating test cases that can be used later in other debugging sessions or even in other cycles of the software development. The proposed framework is general enough to be instantiated to very different programming languages: Erlang (functional), Java (imperative, object-oriented), and SQL (data query); and the experimental results obtained for Erlang programs validate the effectiveness of the framework.We propose a general unified framework for debugging and testing that simplifies each phase and maximizes the reusability of the outcomes in the different phases of the software development cycle, therefore reducing the overall effort.

The Evaluation Dependence Tree as a Basis for Lazy FunctionalDebugging

Lazy functional languages are declarative and allow the programmer to write programs where operational issues such as the evaluation order are left implicit. This should be reflected in the design of debuggers for such languages to avoid burdening the programmer with operational details, e.g. concerning the actual evaluation order. Conventional debugging techniques tend to focus too much on operational aspects to be suitable in this context. A record of the execution that only captures the declarative aspects of the execution, leaving out operational details, would be a viable basis for debugging lazy functional programs. Various declarative debugging tools could then be developed on top of such records. In this paper we propose a structure which we call the Evaluation Dependence Tree (EDT) for this purpose, and we describe two different construction methods. Performance problems are discussed along with possible solutions.

Belief Revision in Non-Monotonic Reasoning and Logic Programming

In order to be able to explicitly reason about beliefs, we've introduced a non-monotonic formalism, called the Autoepistemic Logic of Beliefs, AEB, obtained by augmenting classical propositional logic with a belief operator, β. For this language we've defined the static autoepistemic expansions semantics. The resulting nonmonotonic knowledge representation framework turned out to be rather simple and yet quite powerful. Moreover, it has some very natural properties which sharply contrast with those of Moore's AEL. While static expansions seem to provide a natural and intuitive semantics for many belief theories, and, in particular, for all affirmative belief theories (which include the class of all normal and disjunctive logic programs), they often can lead to inconsistent expansions for theories in which (subjective) beliefs clash with the known (objective) information or with some other beliefs. In particular, this applies to belief theories (and to logic programs) with strong or explicit negation. In this paper we generalize AEB to avoid the acceptance of inconsistency provoking beliefs. We show how such AEB theories can be revised to prevent belief originated inconsistencies, and also to introduce declarative language level control over the revision level of beliefs, and apply it to the domains of diagnosis and declarative debugging. The generality of our AEB framework can capture and justify the methods that have been deployed to solve similar revision problems within the logic programming paradigm.

Foundations of declarative debugging in arbitrary logic programming

Declarative debugging is an interactive process where the debugger acquires knowledge from an oracle (usually the user) about the intended interpretation of a program to be debugged and uses it to compare with the machine interpretation of the program in order to find the error in that program. The debugging is declarative in the sense that the user need only know the logic aspect of a program (i.e. its declarative meaning) and does not need to consider the computational behaviour of the program. An error is found by checking the validity of the solved goals with respect to their intended interpretation. In this paper, we introduce the basic ideas and concepts of declarative debugging, and provide a theoretical foundation with emphasis on the study of soundness and completeness for declarative debugging in arbitrary (unrestricted) first order logic programming.

DDS: A declarative debugging system for functional programs

AbstractThis paper describes the outline and implementation of the declarative debugging system DDS. The purpose of DDS is to provide the following debugging system for the functional program without a side effect: (1) The programmer specifies the result of execution and the intermediate result expected to the program (defines in a declarative way, and the system detects the bug automatically based on that specification; (2) an efficient guide is provided to the programmer so that the required input is less and the input can easily be given; and (3) the system has an efficient bug detection mechanism in terms of the memory capacity and the computational complexity. It is an interactive system which can be applied to a wide range of programs. This paper proposes a mechanism called filter, which gives an efficient realization of DDS. The filter is a mechanism which realizes the tabulation technique by a small‐capacity memory, by extending the technique from the viewpoint of the bug detection. The filter is a mechanism which selectively retains the instances needed in the bug detection and controls the function call of the program using the retained data. An experimental system of DDS is constructed on VAX/VMS using Common Lisp. Debugging examples are shown, indicating the usefulness of DDS.