Although the language Lucid was not originally intended to support computing with infinite data structures, the notion of (infinite) sequence quickly came to the fore, together with a demand-driven computation model in which demands are propagated for the values of particular values at particular index points. This naturally generalized to sequences of multiple dimensions so that a programmer could, for example, write a program that could be understood as a (nonterminating) loop in which one of the loop variables is an infinite vector. Programmers inevitably found use for more and more dimensions, which led to a problem which is fully solved for the first time in this paper. The problem is that the implementation's cache requires some estimate of the dimensions actually used to compute a value being fetched. This estimate can be difficult or (if dimensions are passed as parameters) impossible to obtain, and the demand-driven evaluation model for Lucid breaks down. We outline the evolution of Lucid which gave rise to this problem, and outline the solution, as used for the implementation of TransLucid, the latest descendant of Lucid.

We present a new means for specifying multiple interacting streams, as is needed for documents with multiple systems of notes, side-by-side translations, and critical editions. Each stream is treated as a sequence of components, and anchors are used in the concrete syntax to define reference points used by other streams. When these streams are loaded into memory, the anchors simply become iterators in a container. We present a set of algorithms for the typesetting of multiple streams of text, each with multiple streams of floats and footnotes.

In this paper, we propose a general notion of character which encompasses two concepts: points within a character set, such as Unicode, as well as arbitrary tuples defining structured objects. We call these general characters "charactles". Using this model, text can be defined to be a linear sequence of charactles, not requiring the use of hierarchical structures to encodethe text. As a result, all sorts of processing, such as searching and typesetting, are potentially simplified.

We demonstrate how TransLucid can be used as a reactive system by introducing sets and privileged dimensions for time and port in the language. At each instant, there is a set of active ports, where sets of equations, demands and threads are all registered. Each thread defines a sequence of (state, demand) pairs and threads may interact through the overall set of equations. The entire system remains fully declarative.

The TransLucid programming language is a low-level intensional language, designed to be sufficiently rich for it to be the target language for translating the common programming paradigms into it, while still being fully declarative. The objects manipulated by TransLucid, called hyperdatons, are arbitrary-dimensional infinite arrays, indexed by multidimensional tuples of arbitrary types. We present the syntax, denotational and operational semantics for a simple TransLucid system, consisting of (1) a header detailing how expressions should be parsed, (2) a set of libraries of types, and operations thereon, defined in a host language, (3) a set of TransLucid equations, and (4) a TransLucid demand to be evaluated. The evaluation of a demand for an (identifier,context) pair is undertaken using eduction, where previously computed pairs are stored in a cache called a warehouse. The execution ensures that only those dimensions actually encountered during the execution of an expression are taken into account when caching intermediate results.

Provides a listing of current committee members and society officers.

We propose the synchronous community, a set of context- aware programs held together by a single shared context that permeates all of the programs, together with a synchronous discrete semantics. The different programs may communicate point-to-point or by making changes to the shared context. With the synchronous semantics, changes to the context will be perceived by all other programs, but only in the subsequent instant. As a result, it becomes possible to define the semantics for an entire community, and even for multiple interacting communities.

We present the Eager TransLucid language, an inten- sional programming language in which the value of a variable is a function mapping multidimensional contexts - the "possible worlds" of intensional logic - to ground values or, equivalently, that variables define multidimensional arrays of arbitrary dimensionality. The Eager TransLucid language is a natural generalisation of Wadge and Ashcroft's Lucid dataflow language. Given a specific set of equations and a context, the operational semantics determines the value taken by a variable in that context, which may depend both on the values of dimensions within the context and the values of variables in other contexts. The contexts correspond to tags in tagged-token dataflow systems. The key contribution of the paper is to prove that it is possible to create a warehouse caching the values of already computed (identifier, context) pairs in such a way as to ensure that no reference is made to unnecessary dimensions. The method consists of storing demands for relevant dimensions in the current context as these are needed.

We present an implementation of the TransLucid language, in which expressions are evaluated in a dynamic context of arbitrary dimensionality. The basis for this implementation is the TransLucid virtual machine (TVM), whose execution supposes a centralised cache storing intermediate computed values and whose individual threads compute the values for (identifier, context) pairs. The TVM is designed so that it is efficiently implementable on a wide variety of physical architectures.

Abstract Sloth is a simple Unix‐based tool for creating and maintaining large C programs built from reusable ‘modules’. Sloth is a collection of UNIX shell commands for creating and editing modules, and for producing executables by linking compiled code from the modules comprising a program. Sloth in a sense extends C by providing module facilities similar to those built in to newer languages such as Modula‐II. The Sloth ‘extensions’, however, are at the shell level only. No changes are required in C itself; in fact, the Sloth commands invoke the standard Unix C compiler. A Sloth module contains a set of C procedures and local declarations, a set of global definitions and variable declarations, an initialization routine and an ‘import’ list of other modules containing declarations referred to, but not defined by, the module in question. The Sloth link command has one argument, the name of a ‘root’ directory. The link command automatically identifies all those modules imported directly or indirectly by the root module, checks that the object code for each module is up‐to‐date and recompiles where necessary. It then creates a main program in which the various initialization routines are executed in the correct order (most primitive first), compiles it and links it with all the object files and produces an executable program. Individual modules can be compiled without any knowledge of the application that uses, directly or indirectly, the module in question. Two applications that both use a collection of modules can therefore share the object code for these modules. The use and implementation of Sloth are presented, as are the experience in using it, programming techniques developed to take full advantage of its facilities, as well as several extensions, either completed or planned.

A method for controlling versions of software and other hierarchically structured entities is presented. Using the variant structure principle, a particular version of an entire system is formed by combining the most relevant existing versions of the various components of the system. An algebraic version language that allows histories (numbered series), subversions (or variants), and joins is described. It is shown that the join operation is simply the lattice least upper bound and together with the variant structure principle, provides a systematic framework for recombining divergent variants. The utility of this approach is demonstrated using LEMUR, a programming environment for modular C programs, which was developed using itself. The ways in which this notion of versions is related to the possible world semantics of intensional logic are discussed.>

LUSTRE is a synchronous data-flow language for programming systems which interact with their environments in real-time. After an informal presentation of the language, we describe its semantics by means of structural inference rules. Moreover, we show how to use this semantics in order to generate efficient sequential code, namely, a finite state automaton which represents the control of the program. Formal rules for program transformation are also presented.