[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

Tgim Progress Report

For almost as long a Self has been publicly available, I have
been working on Tarraingim (Tgim for short), an abstract program
visualisation system written in Self.  I've been keeping a low profile
on the mailing list recently, as I've been trying to finish writing
the work up, but seeing some new faces on the list recently (plus
messages from some old ones) I though perhaps people may appreciate a
description of what I've been doing with Self.

Unlike the Seity user interface, Tgim presents objects as
abstractions, rather than concrete collections of slots.  Tgim thus
lies between language user interfaces or graphical debuggers, which
display the low-level structures of programs, and algorithm animation
systems which illustrate programs' higher-level features.  So Tgim can
produce standard slot-level displays of Self objects, but also
provides a framework by which the user can also design customised
views.  The main examples implemented with Tgim to date are
Balsa-style views of sorting algorithms and a collection of views
(including parse tree and FSM graph) of a small recursive-descent

Tgim is based upon three main kinds of objects --- encapsulators,
views, and watchers. Encapsulators monitor the execution of objects in
the target Self program. They are created as needed by Tgim, and can
be dynamically attached to most types of Self object. Views provide
the visualisations, and handle user input.  They are usually
implemented in Self and Xlib, although more sophisticated program
animation libraries can be used.  Watchers link views and
encapsulators and embody strategies used to direct the
monitoring of target objects. They are important because Tgim's
abstract views refer to objects only via their interface.

Tgim can also be compared to a simple constraint system such as
ThingLab or Garnet's KR.  The differences arise because Tgim works
with objects, while most constraint systems work with values of
variables.  Tgim can monitor the messages received by objects, where
constraint systems monitor only assignments to variables. Constraint
systems usually provide many primitive operators to construct
constraints (eg arithmetic operations) but these must be programmed
explicitly in Tgim. Tgim uses coarse dataflow tracing (or user defined
demenes) to handle aliasing, allowing constraints to be defined using 
the abstract operations (i.e. methods) of the target objects.

Active work on Tgim is comming to a close --- I'm concentrating on
writing up rather than coding. The current version of Tgim is rather
slow, and relies on a odd version of Self --- it needs both unwind
protection and prioritised inheritance. I have various projects I
would like complete, including conversion to Self 3.0, incorporating a
"real" constraint solver (delta-blue) and adapting of Bay's Seity to
use encapsulators, along with the construction of more detailed
examples. I'm planning on finishing the thesis towards the end of the
year - how much development is completed will depend on how the
writing goes.

As part of the thesis report, I would like to discuss any other
related work in Self, either the program visualisation or reflexive
language aspects. I am aware of a few projects - Merlin, Ego,
ObjectWorld, but I'm sure there are others. I seem to recall a paper
somewhere about reifying maps and types in Self , but I can't find the
reference. I would also be interested in any other general comments.

Incidently, for any of you at ECOOP who have managed to see this, one
of my project supervisors, Robert Biddle, is also attending the
conference. I'm sure he would enjoy talking to others interested in
Self of program visualisation.

And of course, should anyone know of possible job openings for
experienced postdoctoral Self programmers, I'd appreciate hearing
from them :-)


James "kjx" Noble

James Noble, Graduate Student, Computer Science Department
Victoria University, Box 600, Wellington 1, New Zealand