Traces of program executions are a helpful source of information for automated debugging. They, however, usually give a too low level picture of the executed program. Opium, our extendable trace analyser for Prolog, is connected to a "standard" tracer. Opium is programmable and extendable. It provides a trace query language and abstract views of executions which solve the problems of low-level traces. Opium has shown its capabilities to build abstract tracers and automated debugging facilities. This article describes the trace query mechanism, from the model to its implementation. Characteristic examples are detailed. Extensions written so far on top of the trace query mechanism are listed. Two recent extensions are presented: the abstract tracers for the LO (Linear Objects) and the CHR (Constraint Handling Rules) languages. These two extensions were specied and implemented within a few days. They show how to use Opium for real applications.

: Traces of program executions are a helpful source of information for automated debugging. They, however, usually give a too low level picture of the executed program. Opium, our extendable trace analyser for Prolog, is connected to a "standard" tracer. Opium is programmable and extendable. It provides a trace query language and abstract views of executions which solve the problems of low-level traces. Opium has shown its capabilities to build abstract tracers and automated debugging facilities. This article describes the trace query mechanism, from the model to its implementation. Characteristic examples are detailed. Extensions written so far on top of the trace query mechanism are listed. Two recent extensions are presented: the abstract tracers for the LO (Linear Objects) and the CHR (Constraint Handling Rules) languages. These two extensions were specified and implemented within a few days. They show how to use Opium for real applications. Key-words: Software Engineering, Auto...

: We consider specications of analysers expressed as compositions of two functions: a semantic function, which returns a natural semantics derivation tree, and a property dened by recurrence on derivation trees. A recursive denition of a dynamic analyser can be obtained by fold/unfold program transformation combined with deforestation. We apply our framework to the derivation of a slicing analysis for a logic programming language. Key-words: systematic derivation, program transformation, natural semantics, proof tree, slicing analysis. (R#sum# : tsvp) Unite de recherche INRIA Rennes IRISA, Campus universitaire de Beaulieu, 35042 RENNES Cedex (France) Telephone : 02 99 84 71 00 - International : +33 2 99 84 71 00 Telecopie : 02 99 84 71 71 - International : +33 2 99 84 71 71 D#rivation d'analyseurs # partir d'une s#mantique naturelle par pliage/d#pliage, application # l'analyse d'#lagage R#sum# : Nous consid#rons la sp#cication d'un analyseur comme la composition de deux fonctio...

Abstract. Program slicing has been mainly studied in the context of imperative languages, where it has been applied to many software engineering tasks, like program understanding, maintenance, debugging, testing, code reuse, etc. This paper introduces the first forward slicing technique for multi-paradigm declarative programs. In particular, we show how program slicing can be defined in terms of online partial evaluation. Our approach clarifies the relation between both methodologies and provides a simple way to develop program slicing tools from existing partial evaluators. 1

Abstract. Program slicing is a well-known methodology that aims at identifying the program statements that (potentially) affect the values computed at some point of interest. Within imperative programming, this technique has been successfully applied to debugging, specialization, reuse, maintenance, etc. Due to its declarative nature, adapting the slicing notions and techniques to a logic programming setting is not an easy task. In this work, we define the first, semantics-preserving, forward slicing technique for logic programs. Our approach relies on the application of a conjunctive partial deduction algorithm for a precise propagation of information between calls. We do not distinguish between static and dynamic slicing since partial deduction can naturally deal with both static and dynamic data. A slicing tool has been implemented in ecce, where a post-processing transformation to remove redundant arguments has been added. Experiments conducted on a wide variety of programs are encouraging and demonstrate the usefulness of our approach, both as a classical slicing method and as a technique for code size reduction. 1

Despite these expected benefits, declarative debugging is not yet widely used in practice to find real bugs. There are three main reasons for this: 1. Most previous declarative debuggers only support a subset of the features of their target language that is not sufficient to express real programs. 2. Previous declarative debuggers do not scale well when applied to problems with large search spaces. 3. Previous declarative debuggers do not do enough to make the questions easier for the user to answer. The declarative nature of Mercury makes it relatively easy to implement a declarative debugger that can handle the full language. The version of the Mercury declarative debugger that was the starting point for this thesis already handled almost all of Mercury. By extending it to handle exceptions we made it handle the full language

We have implemented a declarative debugger for Mercury that is capable of finding bugs in large, long-running programs. This debugger implements several search strategies. We discuss the implementation of two of these strategies and the conditions under which each strategy is useful. The divide and query strategy tries to minimize the number of questions asked of the user. While divide and query can reduce the number of questions to roughly logarithmic in the size of the computation, implementing it presents practical difficulties for computations whose representations do not fit into memory. We discuss how we get around this problem, making divide and query practical. Our declarative debugger allows users to specify exactly which part of an atom is wrong. The subterm dependency tracking strategy exploits this extra information to jump directly to the part of the program that computed the wrong subterm. In many cases, only a few such jumps are required to arrive at the bug. Subterm dependency tracking can converge on the bug even more quickly than divide and query, and it tends to yield question sequences that are easier for users to answer.

. Slicing is a technique for automatically obtaining subparts of a program with a collective meaning. When the slicing takes into account the actual execution of the program, it is said to be dynamic; when only statically available information is used, it is said to be static. In this paper we describe a flexible framework to slice logic programs that accommodates both dynamic and static approaches naturally. Our framework addresses practical aspects of logic programs such as different executions, system predicates and side-effects and can be customized to any logic language, provided we have its (concrete or abstract) interpreter and information on the behavior of system predicates. Keywords. Logic program slicing, program analysis & understanding. 1 Introduction Slicing is a technique for obtaining subparts of a program with a collective meaning. It was originally proposed by Weiser [35, 36], in the context of procedural languages. When we slice a program, we are interest...

We present a slicing approach for analyzing logic programs with respect to non-termination. The notion of a failure-slice is presented which is an executable reduced fragment of the program. Each failureslice represents a necessary termination condition for the program. If a failure-slice does not terminate it can be used as an explanation for the non-termination of the whole program. To effectively determine useful failure-slices we combine a constraint based static analysis with the dynamic execution of actual slices. The current approach has been integrated into a programming environment for beginners. Further, we show how our approach can be combined with traditional techniques of termination analysis.

Slicing is a process for automatically obtaining subparts of a program with a collective meaning. It has been employed within conventional procedural programming to solve a number of software development issues. We have adapted and extended slicing techniques originally proposed for procedural languages, to knowledge-based systems. Our techniques comprise a representation proposal for the successful and failed inferences performed by the system, a means to detect and represent the dependences among parts of the system, a formal definition of relevance among these parts and an algorithm proven correct to obtain executable slices of a system. We illustrate the usefulness of the slicing process with practical examples. Keywords. Slicing techniques, automated support, development and reuse of systems. 1 Introduction Knowledge-based systems (KBS's), as any other piece of software, are prone to the usual difficulties of program development, maintenance and reuse. Program slicing, a ...