Christian Queinnec and Bernard Serpette. A Dynamic Extent Control Operator for Partial Continuations. In POPL '91 - Eighteenth Annual ACM symposium on Principles of Programming Languages, pages 174-184, Orlando (Florida, USA), January 1991.
A partial continuation is a prefix of the computation that remains to be done. We propose in this paper a new operator which precisely controls which prefix is to be abstracted into a partial continuation. This operator is strongly related to the notion of dynamic extent which we denotationally characterize. Some programming examples are commented and we also show how to express previously proposed control operators. A suggested implementation is eventually discussed.
Christian Queinnec, editor. Actes des JFLA 91 - Journées Francophones des Langages Applicatifs, Grèsse en Vercors (France), January 1991. Revue Bigre+Globule 72.
Christian Queinnec. Crystal Scheme, A Language for Massively Parallel Machines. In M Durand and F El Dabaghi, editors, Second Symposium on High Performance Computing, pages 91-102, Montpellier (France), October 1991. North Holland.
Massively parallel computers are built out of thousand conventional but powerful processors with independent memories. Very simple topologies mainly based on physical neighbourhood link these processors. The paper discusses extensions to the Scheme language in order to master such machines. Allowing arguments of functions to be concurrently evaluated introduces parallelism. Migration across the different processors is achieved through a remote evaluation mechanism. We propose a clean semantics for first class continuations in presence of concurrency and show how they can be used to build, in the language itself, advanced concurrent constructs such as futures. Eventually we comment some simulations, with various topologies and migration policies, which enables to appreciate our previous linguistical choices and confirms the viability of the model.
Christian Queinnec and Julian Padget. Modules, macros and Lisp. In Eleventh International Conference of the Chilean Computer Science Society, pages 111-123, Santiago (Chile), October 1991. Plenum Publishing Corporation, New York NY (USA).
Many modern languages offer a concept of modules to encapsulate a set of definitions and make some of them visible from outside. Associated to modules are directives ruling importations and exportations as well as controlling other capabilities like renaming or qualified notation. We propose here a language to handle sets of named locations with the aim of describing precisely which locations are to be shared between modules and under which local names they are known. The language is symmetric for imports and exports. It is also extensible since it provides a framework to handle named locations. Mutability, for instance, can readily be expressed thanks to a simple extension of our language. Another more subtle extension is to offer a protocol for modules with ``macros''. Macros allow a user to extend the syntax of a language by providing rewriting rules expressed as computations performed on the representation of programs. Lisp is a language offering macros and much of its extensibility stems from them. However, many problems arise from macros, amongst them being the exact definition of when, where and how the macroexpansion is done to turn the body of a module using extended syntaxes into a regular form in the bare, unextended language. This paper presents, in the framework of Lisp, a definition of modules offering tight control over module environments as well as a precise semantics of separate compilation and macroexpansion. These new (for Lisp) capabilities definitely add some power relative to the management of name spaces but also justify compiling optimizations (inlining, partial evaluation etc.) and, above all, turn Lisp into a language suitable for application delivery since applications are finite collections of modules. Our proposal contributes to a vision of Lisp composed of a multitude of linked and reusable modules. Our results concerning name space management and macros can also be applied to other languages. Two different implementations of these concepts exist: in FEEL, the implementation of EuLisp done by the University of Bath and in the idiom of Icsla, a dialect of Lisp designed at INRIA-Rocquencourt and École Polytechnique. This paper reflects the results of the experiments carried out in these systems during the last year.
Christian Queinnec and Julian Padget. A proposal for a modular Lisp with macros and dynamic evaluation. In Journées de Travail sur l'Analyse Statique en Programmation Équationnelle, Fonctionnelle et Logique, pages 1-8, Bordeaux (France), October 1991. Revue Bigre+Globule 74.
Lisp has some specialised capability for reflective operations, exemplified by its macro facility, structured name spaces, file compilation, file loading and dynamic code synthesis. There has been some progress in the last few years on the semantics of macros, but the other operations have been categorized as environmental issues. In this paper, we present a semantics for modules and will show that it substantially reduces the difficulty of defining precisely several features of usual Lisp systems such as macros, module compilation (file compilation), module loading (fasl loading) and dynamic evaluation. The module schema addresses the questions of name visibility and separate compilation. Macro-expansion is specified relative to where and how it takes place as one of the operations on modules.
Christian Queinnec. MEROON: A small, efficient and enhanced object system. Technical Report LIX.RR.92.14, École Polytechnique, Palaiseau Cedex, France, November 1991.
Meroon is a very simple object system and therefore is easy to master at the usual level or at the meta-level. Regular usage requires to know only three macros (define-class, define-generic and define-method) as well as some naming rules to be able to use all the various functions that are automatically generated when classes are defined. Yet Meroon is not too inefficient since to send a message costs approximatively 2.5 function calls independently of the number of methods defined on the class. Moreover Meroon is easily portable. Some parts may of course be improved if functions can be inspected or if weak pointers are offered in the underlying Scheme system. Meroon also provides some features not found elsewhere such as the possibility to have indexed fields combined with unrestricted inheritance. This capability allows an implementation to only provide Meroon objects instead of vectors and structures etc.
© C. Queinnec fecit (2012-02-19)