HAL group's student doing graphic debugger

Fergus Henderson fjh at cs.mu.OZ.AU
Thu Dec 3 02:17:15 AEDT 1998

-----Forwarded message from Maria Garcia de la Banda <mbanda at cs.monash.edu.au>-----

Date: Mon, 30 Nov 1998 10:34:23 +1100 (EST)
From: Maria Garcia de la Banda <mbanda at cs.monash.edu.au>
To: fjh at cs.mu.OZ.AU, conway at cs.mu.OZ.AU
Subject: Summer student


We have got a summer student to develop a very basic graphical debugger for
HAL (starting from Mercury). The main aim is not to implement a real tool
but to get him to know HAL, Mercury, etc, and, if he likes it (and we like
his work), to continue with an honors project and (hopefully) a PhD in
whatever HAL-related issue he wants to do. We do not even care if he does
something that you guys are already done, the idea is for him to taste a
bit of everything and The text I included below will give you an idea of
what we thought he could do (although we only expect him to do a small part
of what it is said there).

Anyway, the thing is, the new version of Mercury has now a debugger and
Warrick told me you have people developing graphical interfaces for it, so,
I am sure you have a lot of experience that could be useful to our summer
student (his name is Gregory Denehy). Things like: where to find the last
tcl/tk interface and its documentation (and possibly who to talk to about
this), what kind of information can the debugger provide in order to build
the execution tree (will he have to dig in the mercury sources, or is there
any kind of standard interface which includes the information he is likely
to need, etc). So, who can he talk to, or where can he look into?

Thanks in advance for the info!




      Supervisors: Maria Garcia de la Banda and Kim Marriott

The constraint programming (CP) paradigm has had remarkable industrial
success even though it is quite recent. This is because CP languages
currently provide one of the best approaches for developing efficient
solutions to many combinatorial problems such as planning, scheduling,
routing and investment. 

However, there are remarkable few debugging tools for CP languages, in
particular tools which provide the programmer with the necessary
information to improve the performance of the application. This is crucial
in many combinatorial problems due to their inherit complexity. For
example, visualizing the execution tree can aid the programmer
understanding how to improve the search strategy. Indeed, to the best of
our knowledge, only two such tools have been proposed: Grace and the
Oz-Explorer, and they are both far from ideal.

Our long term goal is to develop a visualization tool which is general,
efficient, interactive, modular, provides both comparison and analytical
capabilities, and which is graphical in nature. This tool will be
developed for the second generation constraint programming language HAL,
which is currently being developed by us in collaboration with other groups
inside and outside Monash University. Funding for the visualization tool is
currently being sought through a small ARC grant. Funding for a summer
student would provide a basis for this tool and, hopefully, would attract
somebody to continue on the (hopefully) small ARC sponsored project.

The aim of the summer project is to implement a graphical front-end to
Mercury's current textual debugger. Mercury is an efficient logic
programming language to which HAL is compiled. The graphical front-end will
provide three windows showing the following information:

       * Source: shows the mercury source program. Allows the programmer to
         select spy points and the initial goal.

       * Trace: shows the mercury debugging trace based on the standard
         ``Byrd box'' execution model. The usual retry, skip, creep, etc,
         commands will be provided.

       * Execution tree: shows the execution tree. For space reasons some
         predicates will be hidden. The user will be allowed to expand
         selected predicates.

The underlying algorithms and user interfaces needed to develop this
project are very well known. The summer student's task will be to implement
this tool in Tcl/Tk and interface it to Mercury. We are ready to fund an
additional two-four weeks in order to ensure the completion of the project.

The student should be either 3rd or 4th year and, preferably, have a
knowledge of Prolog and graphical user interfaces.

-----End of forwarded message-----

Fergus Henderson <fjh at cs.mu.oz.au>  |  "Binaries may die
WWW: <http://www.cs.mu.oz.au/~fjh>  |   but source code lives forever"
PGP: finger fjh at        |     -- leaked Microsoft memo.

More information about the developers mailing list