this paper. associated with a relocating collector is saved; other costs remain, however, such as the costs of updating all pointers and foregoing some compiler optimizations.

. This paper presents a new dialect of Scheme aimed towards concurrency and distribution. It offers a few primitives, including first-class continuations, with very simple semantics. Numerous examples are given showing how to program the classical concurrent control operators such as future, pcall and either. The implementation is sketched and presented along the lines of a metacircular interpreter. This paper presents the idiom of Icsla 1 , a language belonging to the Lisp family and more precisely a descendant of Scheme. This dialect has been designed with respect to the following main objectives: -- It should have a very simple and understandable semantics, with few but powerful and unrestrictively combinable concepts; -- It should offer concurrency, distribution and some other modern features such as sophisticated control features while not sacrificing the variety of styles traditionally offered by Lisp. These goals are rather general and deserve further comment. Following Sche...

The Meroon object system was originally invented for a book to describe implementations of Lisp and Scheme. It was designed to have a pedagogical but efficient implementation, to support separate compilation yet to be powerful enough to unify all the datatypes of Scheme even vectors and strings without restriction of inheritance. While designing a distributed extension of Scheme [QD93], new needs appeared that a new release of Meroon tries to satisfy. This paper exposes these problems and how they are solved in Meroon V3. Among these new features are (i) compact dispatchers for generic functions, (ii) a new initialization protocol for a better control of mutability, (iii) a new vision of metaclasses as a code generation mechanism in relation to separate compilation. The paper first recalls the previous state of Meroon, presents the new needs then their associated solutions.

This paper discusses work which is a continuation of [Baker90]. Our birth control scheme for objects of LP type bears a strong resemblance to Barnes'es scheme for controlling access to a resource [Barnes89,9.3]. Barnes does not export a nesting generic unit to handle deallocation, however.

The AQUA [16] query algebra allows user-defined equivalence relations as arguments to query operators that generalize standard set operations. These predicates determine what objects are included in the query result, and the duplicates that must be removed. While an expressive enhancement, the use of arbitrary equivalence relations to decide set membership can result in sets with counterintuitive behavior, and therefore can make queries return unreasonable results. In this paper, we show that equality predicates assume two roles with respect to sets. Distinguishers differentiate between set members and implicitly give meaning to standard set properties such as set equality. Constructors determine which object from input sets contribute to the query result. The requirements of distinguishers and constructors differ. AQUA's set operators are problematic because they use constructors where distinguishers are required. We propose alternatives to AQUA's set operators that address this limit...

This paper and [Baker91SP] show that Mendal was needlessly pessimistic.

this paper. In short, the choice of which "macros" are "special forms" is just as arbitrary as the choice of a axes in a coordinate system for the Cartesian X-Y plane---e.g., some sets of macros are "linearly independent", and some sets of macros "span" the space of special forms. Some of our emulations may only be approximate, in the sense that certain syntactic variations are not supported, and certain error conditions are not recognized. These emulations are meant to be only a starting point for a serious effort in pinning down the semantics of Common Lisp, and significant additional effort will be required to complete this task.

The ability of an object to mutate is one of the defining characteristics of Object-Oriented Databases (OODBs). But the impact of object mutability on querying is typically ignored. Presumably, this is because queries are usually assumed free of side-effects, and therefore objects are effectively immutable while they are queried. But mutability affects other object behaviors aside from how they change, such as how they are compared for equality, and if it is possible to detect that they are shared. In this paper, we show how these behaviors impact querying in general and query optimization and mutable set construction in particular. The issues considered in this paper arose during our efforts to provide OQL-based [Cat96] query facilities for Thor [LJGS90, LAC + 96]. Whereas OQL (and specifically, the ODMG object model) make specific assumptions about the mutability of sets, Thor had not adopted a policy for sets when this project began. In formulating a policy, we considered the impact...

Parallel computers offer the ability to reduce the run-time of large and complex discrete event simulations. Most research into Parallel Discrete Event Simulation (PDES) is based on libraries for existing languages, such as C and C++. This library-based approach exposes the user to the synchronisation protocols used to ensure that events are processed in the correct order, and produces simulators that are less expressive than simulation-oriented languages (for example, Simula and MODSIM II). The use of a simulation-oriented language for PDES allows the synchronisation protocols to be hidden from the user and enables optimisations to be performed that are usually difficult or cumbersome, such as granularity control. A simulation-oriented language could therefore improve the usability of PDES, the lack of which has generally inhibited its widespread take-up. This thesis focuses on the run-time support needed for simulation-oriented languages for PDES using a new language cal...

The Comparand pattern provides a means to interpet different objects as being identical for certain contexts. It does so by introducing an instance variable in each class of interest - the comparand - and using it for comparison. Identification of different objects is needed when more than one reference refers to the (conceptually) same objects. In distributed systems, the Comparand pattern provides for efficient comparison of remote objects.