WLPE on Wednesday

Detailed program
Wednesday July 31st, 2002
See also the unified by-slot program


All sessions take place in auditorium 7.

Session 1: Constraints

Chair: Alexandre Tessier

09:00-09:30  Magnus Ĺgren, Swedish Inst. of Computer Science, Sweden
Tamás Szeredi, Swedish Inst. of Computer Science, Sweden
Nicolas Beldiceanu, Swedish Inst. of Computer Science, Sweden
Mats Carlsson, Swedish Inst. of Computer Science, Sweden
Tracing and explaining execution of CLP(FD) programs
Previous work in the area of tracing CLP(FD) programs mainly focuses on providing information about control of execution and domain modification. In this paper, we present a trace structure that provides information about additional important aspects. We incorporate explanations in the trace structure, i.e. reasons for why certain solver actions occur. Furthermore, we come up with a format for describing the execution of the filtering algorithms of global constraints. Some new ideas about the design of the trace are also presented. For example, we have modeled our trace as a nested block structure in order to achieve a hierarchical view. Also, new ways about how to represent and identify different entities such as constraints and domain variables are presented.

09:30-10:00  Samir Ouis, Ecole des Mines de Nantes, France
Narendra Jussien, Ecole des Mines de Nantes, France
Patrice Boizumault, U Caen, France
COINS: a constraint-based interactive solving system
This paper describes the COINS (COnstraint-based INteractive Solving) system: a conflict-based constraint solver. COINS is an improved constraint solver that helps understanding inconsistencies, simulates constraint additions and/or retractions (without any propagation), determines if a given constraint belongs to a conflict and provides diagnosis tools (e.g. why variable v cannot take value val). COINSprovides user-friendly representation of conflicts and explanations.

10:00-10:30  Willy Lesaint, U Orléans, France
Value withdrawal explanations: a theoretical tool for programming environments
Constraint logic programming combines declarativity and efficiency thanks to constraint solvers implemented for specific domains. Value withdrawal explanations have been efficiently used in several constraints programming environments but there does not exist any formalization of them. This paper is an attempt to fill this lack. Furthermore, we hope that this theoretical tool could help to validate some programming environments. A value withdrawal explanation is a tree describing the withdrawal of a value during a domain reduction by local consistency notions and labeling. Domain reduction is formalized by a search tree using two kinds of operators: operators for local consistency notions and operators for labeling. These operators are defined by sets of rules. Proof trees are built with respect to these rules. For each removed value, there exists such a proof tree which is the withdrawal explanation of this value.

Session 2: Constraints, Object-oriented

Chair: German Puebla

11:00-11:30  François Fages, INRIA Rocquencourt, France
CLPGUI: a generic graphical user interface for constraint logic programming over finite domains
CLPGUI is a graphical user interface for visualizing and interacting with constraint logic programs over finite domains. In CLPGUI, the user can control the execution of a CLP program through several views of constraints, of finite domain variables and of the search tree. CLPGUI is intended to be used both for teaching purposes, and for debugging and improving complex programs on real size data. It is based on a client-server architecture for connecting the CLP process to a Java-based GUI process. Communication by message passing provides an open architecture which facilitates the reuse of graphical components and the porting to different constraint programming systems. Constraints and goals can be posted incrementally from the GUI. The level of granularity of the search tree is speciaed by annotations in the CLP program. The visualized search tree is a subtree of the SLD derivation tree with constraints. We propose several dynamic 2D and 3D visualizations of the search tree and of the evolution of finite domain variables. We describe the current implementation of the annotations and of the interactive execution model in GNU-Prolog, and report some evaluation results.

11:30-12:00  Jan Wielemaker, U Amsterdam, The Netherlands
Anjo Anjewierden, U Amsterdam, The Netherlands
An architecture for making object-oriented systems available from Prolog
It is next to impossible to develop real-life applications in just pure Prolog. With XPCE we realised a mechanism for integrating Prolog with an external object-oriented system that turns this OO system into a natural extension to Prolog. We describe the design and how it can be applied to other external OO systems.

12:00-12:30  Göran Falkman, U Skövde, Sweden
Olof Torgersson, Chalmers U of Techn., Sweden
Enhancing usefulness of declarative programming frameworks through complete integration
If declarative programming languages are to compete with their imperative and object-oriented counterparts as general purpose programming tools, building complete programming environments, including a sufficient set of standard libraries and project management tools, is necessary. An alternative approach is to make use of all the development years put into legacy programming tools, and to combine these with declarative programming. A problem with this integration of different paradigms and tools is that connecting the different parts of a system often is rather complicated, lessening the chance that declarative languages really become used in real-world interactive applications.
The Gisela framework for declarative programming was developed with the specific aim of providing a tool that would be useful for knowledge representation and reasoning within state-of-the-art desktop and web applications. As such, it provides two complete application programming interfaces (api): Programming using objects and programming using a traditional equational declarative style. In addition to providing complete integration into an object-oriented development environment, Gisela also allows extensions and modifications, due to the general computation model and well-defined apis. The framework has been used to develop real-world applications, which are in daily use. We present the declarative model underlying Gisela, the methodology proposed for building applications and give a brief overview of some example applications.

Session 3: Logic programming

Chair: Anthony J. Kusalik

14:00-14:30  Ulrich Neumerkel, Vienna U of Techn., Austria
Stefan Kral, Vienna U of Techn., Austria
Declarative program development in Prolog with GUPU
We present the side-effect free programming course environment GUPU that seamlessly guides and supports students during all phases of program development covering specification, implementation, and program debugging. GUPU features several innovations in this area. The specification phase is supported by reference implementations augmented with diagnostic facilities. During implementation immediate feedback from test cases and visualization tools helps the programmer's program understanding. A set of slicing techniques is used to narrow down programming errors. Finally, the whole process is guided by a marking system.

14:30-15:00  Gopal Gupta, U Texas-Dallas, USA
Deepa Gopal, Logical Software Solutions, USA
Towards a logic programming based environment for automatic generation of translators
We report on the development of a logic programming based environment for automatic generation of translators for translating one formal notation (a programming language, a mark-up language, etc.) to another. Automatic generation of translators will make the task of porting and filtering much faster, thereby improving programmer productivity. Porting (migrating a program from one machine or system to another) and filtering (translating a program written in one particular notation to accomplish a particular task to another notation that accomplishes the same task) are important problems that arise commonly in business computing, since the underlying software, operating system, and hardware change frequently and require the user programs to be modified accordingly. With advent of eXtensible Markup Languages (XML) for WWW, porting/filtering have acquired greater significance as rapidly translating one XML to another XML and vice versa is very important for document interoperability and electronic commerce. Using our graphical tool a programmer will be able to rapidly specify translators by pictorially specifying the parse tree patterns and the semantic mappings between the source and target notations. Our tool will automatically generate the translator code in Prolog from this specification. Automatic generation implies that the generated translator will contain fewer errors compared to a manually written one.

15:00-15:30  Nicos Angelopoulos, Imperial College, UK
Exporting Prolog source code
In this paper we present a simple source code configuration tool. ExLibris operates on libraries and can be used to extract from local libraries all code relevant to a particular project. Our approach is not designed to address problems arising in code production lines, but rather, to support the needs of individual or small teams of researchers who wish to communicate their Prolog programs. In the process, we also wish to accommodate and encourage the writing of reusable code. Moreover, we support and propose ways of dealing with issues arising in the development of code that can be run on a variety of like-minded Prolog systems. With consideration to these aims we have made the following decisions: (i) support file-based source development, (ii) require minimal program transformation, (iii) target simplicity of usage, and (iv) introduce minimum number of new primitives.

Session 4: Abstract interpretation

Chair: Mireille Ducassé

16:00-16:30  Claudio Vaucheret, Techn. U of Madrid, Spain
Francisco Bueno, Techn. U of Madrid, Spain
More precise yet efficient type inference for logic programs
Type analyses of logic programs which aim at inferring the types of the program being analyzed are presented in a unified abstract interpretation-based framework. This covers most classical abstract interpretation-based type analyzers for logic programs, built on either top-down or bottom-up interpretation of the program. In this setting, we discuss the widening operator, arguably a crucial one. We present a new widening which is more precise than those previously proposed. Practical results with our analysis domain are also presented, showing that it also allows for efficient analysis.