Synthesis of the topic "Very high-level languages for development of
applications". 

Introduction
------------

The purpose of this topic was to bring together developers of
programming systems for very high-level languages.  Several developers
were invited, in particular those working on Common Lisp, Python, and
Guile.  Unfortunately, Python and Guile developers declined the
invitation for lack of time.  The meeting was therefore concentrated
on two topics:

   - the development of Free-CLIM, the free version of the Common Lisp
     interface manager, and

   - the development of a common platform for very high-level
     languages on symmetric multi-processor machines.

Free CLIM
---------

As mentioned, Free-CLIM is a free implementation of the Common Lisp
interface manager.  The specification of CLIM is publicly available,
which simplifies the task.  Commercial implementations of CLIM exist
for all commercial Common Lisp systems.

Gilbert Baumann has written a relatively complete implementation of
the code for regions and for transformations.  Mike McDonald has a
mostly transversal implementation of parts of regions,
transformations, sheets, graphic operations, panes (including the
important stream pane), and application frames.  Robert Strandh has a
relatively complete version of the sheet protocols.  Arthur Lemmens
has written code for basic gadget classes.  Iban Hachondo and Julien
Boninfante have written code for some composite panes and currently
work on specific gadget classes such as labels, buttons, menus. 

Four of the people developing Free-CLIM participated in the topic
meeting.  The time was spent on different topics:

  - coding and test of code for panes and gadgets,

  - integration of Gilbert Baumann's code for transformations and
    regions in the code written by Mike McDonald,

  - coding of an install procedure for CMU Common Lisp, allowing full
    compilation and test of existing code, and

  - planning of future development.

Common platform for very high-level languages
---------------------------------------------

This is a project in its infancy, and that has therefore not yet
generated any concrete code.  

The main part of this project will be a multi-processor unintrusive
garbage collector, suited as a basis for the implementation of a
number of high-level languages such as Lisp, Scheme, Python, Java,
etc.  With standardization of function-call protocols,
generic-function dispatch, etc., it could even be possible to mix
modules implemented in different languages (provided, of course, their
semantics are similar).

It is crucial for such a garbage collector to mostly run locally for
each processor, i.e., to minimize synchronization between processors,
and to preserve cache locality as much as possible.  In addition, the
garbage collector must be near real-time in that it must be suitable
for multi-media applications with requirements of latencies in the
order of 1ms.  This can be accomplished with a combination of local
garbage collections (in each processor) of the youngest generation
which would be small enough to fit in the cache, and a real-time
incremental garbage collector for the older generations, it itself
potentially organized as a generational collector. 

Two of the participants spent time planning future actions to get this
project started, and agreed to exchange email to that effect.  In
addition, we discussed ways of testing our ideas without having to
implement the low-level details of a full runtime system.  

Conclusion
----------

The LSM has clearly been advantageous to our projects.  Email is fine
for most day-to-day work, but meeting in person from time to time is
invaluable for future planning and for bouncing ideas for new projects
and new directions of existing projects.  In addition, the LSM allows
ideas to be spread between different groups of developers working on
quite different project.

We look forward to next year's meeting allowing us more time to invite
people, and more time for the invited people to plan their calendars. 


-- 
Robert Strandh