Algorithmic debugging, as presented by Shapiro, is an interactive process where the debugging system acquires knowledge about the expected meaning of a program being debugged and uses it to localize errors. This paper suggests a generalization of the language used to communicate with the debugger. In addition to the usual “yes ” and “no ” answers, formal specifications of some properties of the intended model are allowed. The specifications are logic programs. They employ library procedures and are developed interactively in the debugging process. An experimental debugging system incorporating this idea has been implemented. In contrast to some other systems, its diagnosis algorithms do not require instantiation of unsolved goals by the oracle. This is achieved by generalization of the oracle in the incorrectness algorithm, and by adopting a new approach in the insufficiency algorithm. A formal proof of correctness and completeness of the new insufficiency algorithm is presented. Extensions for some Prolog features are discussed.

This paper discusses the merits of using C, and in particular GNU C, as an intermediate target language for the compilation of logic programs, and describes the approach we have taken in the implementation of Mercury. We start with a simple approach using ANSI C, and investigate a variety of improvements on this basic approach. Keywords: compilation techniques, programming language implementation, logic programming languages, Mercury, C, GNU C. 1 Introduction There are many different ways of implementing a logic programming language, each with its own advantages and disadvantages. Each method makes its own trade-offs in terms of simplicity, portability, interactivity, compilation time, code size, speed at runtime, ease of debugging, interoperation with other languages, and so on. The choice of a particular method must be governed by the relative weights placed on these different trade-offs. This paper discusses the approach we took in the implementation of Mercury [11, 12], a new pure...

Curry is a multi-paradigm declarative language aiming to amalgamate functional, logic, and concurrent programming paradigms. Curry combines in a seamless way features from functional programming and (concurrent) logic programming. Curry’s operational semantics is based on the combination of lazy reduction of expressions together with a possibly non-deterministic binding of free variables occurring in expressions. Moreover, (equational) constraints can be executed concurrently which provides for passive constraints and concurrent computation threads that are synchronized on logical variables. machine for executing Curry programs. The machine is designed to provide a link for compiling Curry programs into Java but it can also be a basis for implementations of Curry in other (object-oriented) languages. The main emphasis of the Java-based implementation is the exploitation of Java threads to implement the concurrent and nondeterministic features of Curry.

Many logic programming implementations compile to C, but they compile to very low-level C, and thus discard many of the advantages of compiling to a high-level language. We describe an alternative approach to compiling logic programs to C, based on continuation passing, that we have used in a new back-end for the Mercury compiler. The new approach compiles to much higher-level C code, which means the compiler back-end and run-time system can be considerably simpler.

This paper is a report on the status of the Mercury system at the time of the release of version 0.6 of the system. We intend to demonstrate the system at the workshop. The contents of this paper is as follows. Section 2 lists the main features of the language. Section 3 shows what is new in the Mercury system since release 0.5, which came out in early 1996. Section 4 gives a broad picture of the state of the implementation. Section 5 discusses the performance of the system, while section 6 lists our current and future research directions.

this paper is to demonstrate how it is possible to implement a complete Prolog system by guaranteeing the double goals of high expressiveness in software description and of efficiency of the resulting system. The fulfilment of these objectives has been possible thanks to a set of tools designed for efficient manipulation of the computation history. These tools, which have been implemented in C, are called `sleepers'. The adoption of these mechanisms leads to a new programming paradigm for which we propose the term `sleeper-oriented programming'. The Prolog system that we have implemented is entirely conceived in this programming style. The implementation choices, the term representation, the memory organization (local stack, heap, trail), and the resource management (last-call optimization) are closely related to the standard implementations of Prolog. The main originality of the system lies in the fact that the traditional Prolog local stack is amalgamated with the runtime stack of the host language, and that this resource, normally so hard to handle in a friendly manner, is easily usable by the sleeper mechanism

Curry is a multi-paradigm declarative language aiming to amalgamate functional, logic, and concurrent programming paradigms. Curry combines in a seamless way features from functional programming and (concurrent) logic programming. Curry's operational semantics is based on the combination of lazy reduction of expressions together with a possibly non-deterministic binding of free variables occurring in expressions. Moreover, (equational) constraints can be executed concurrently which provides for passive constraints and concurrent computation threads that are synchronized on logical variables. This paper sketches a first prototype implementation of Curry in Java. The main emphasis of this implementation is the exploitation of Java threads to implement the concurrent and non-deterministic features of Curry.