 | |
All
sessions take place in auditorium 7.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. |
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. |
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. |
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. |
|
|