A trampolined program is organized as a single loop in which computations are scheduled and their execution allowed to proceed in discrete steps. Writing programs in trampolined style supports primitives for multithreading without language support for continuations. Various forms of trampolining allow for different degrees of interaction between threads. We present two architectures based on an only mildly intrusive trampolined style. Concurrency can be supported at multiple levels of granularity by performing the trampolining transformation multiple times.

Reflection is a wide-ranging concept that has been studied independently in many different areas of science in general, and computer science in particular. Even in the sub-area of programming languages, it has been applied to different paradigms, especially the logic, functional and objectoriented ones. Partly because of different past influences, but also because researchers in these communities scarcely talk to each others, concepts have evolved separately, sometimes to the point where it is hard for people in one community to recognize similarities in the work of others, not to speak about cross-fertilization among them. In this paper, we propose a synthesis covering mainly the application of computation reflection to programming languages. We compare the different approaches and try to identify similar concepts hidden behind different names or constructs. We also point out the different emphasis that has been given to different concepts in each of them. We do not claim neither comp...

In this paper we introduce M-LISP, a simple new dialect of LISP which is designed with an eye toward reconciling LISP's metalinguistic power with the structural style of operational semantics advocated by Plotkin [Plo75]. We begin by reviewing the original denition of LISP [McC61] in an attempt to clarify the source of its metalinguistic power. We nd that it arises from a problematic clause in this denition. We then dene the abstract syntax and operational semantics of M-LISP, essentially a hybrid of M-expression LISP and Scheme. Next, we tie the operational semantics to the corresponding equational logic. As usual, provable equality in the logic implies operational equality. Having established this framework we then extend M-LISP with the metalinguistic eval and reify operators (the latter is a non-strict operator which converts its argument to its metalanguage representation.) These operators encapsulate the metalinguistic representation conversions that occur globall...

interpretation or constraint solving analyses may be used to detect both modalities of size-change behavior, and can be found in the literature [Chin and Khoo 2002; Hughes et al. 1996]. We develop analyses for the current context in Section 5, in the style of Jones et al. [1993, Section 14.3].

Abstract not found

Most accounts of reflection are in an interpreted framework and tend to assume the availability of particular pieces of the state of a program's interpretation, including the current source code expression. This paper presents a computational account of reflection, drawing a distinction between the meta-level manipulation of data or control and the mere availability of meta-circular implementation details. In particular, this account does not presume the existence of program source code at runtime. The paper introduces a programming paradigm that relies on reflective language features and draws on the power of object-oriented programming. Several examples of the use of these features are provided, along with an explanation of a translation-based implementation. The examples include the measurement of computational expense, the introduction of first-class continuations, and the modification of the semantics of expressed values, all in the framework of reflection-oriented programming....

Refci is an extensible reflective language based on the reflective tower model. The Refci interpreter procedures are reifiable, first-class objects, and user programs can directly modify the interpreter by extending them. This allows user code to be run directly as part of, and at the level of, the interpreter. By installing a modified or extended interpreter, user programs can modularly extend the language and implement debugging aids. We present the extensible first-class interpreter and give examples of its use. Examples include stepping, breakpoints, and interrupts. We show how the reflective tower, modeled by the metacontinuation, maintains the proper level of interpretation when running an interpreter containing both system code and user code.

This document proposes these theses: ffl First-class interpreters offer a flexible means of language extensibility. ffl A simple module system can provide: -- incremental specialization -- program construction rather than program organization -- static rather than dynamic composition of programs -- explicit rather than implicit control over composition The former two claims duplicate properties presently associated only with object-oriented programming, while we regard the latter two as improvements. 2 Introduction Software design is language design for particular problems. The functional programming community has stressed the power and flexibility of this view on many occasions [Hen82, AS85, Hug90, Wad87, HS88], and one of the goals of this thesis is to emphasize it once more. According to this point of view, a programming language is a vehicle for constructing problem-specific languages. Existing languages support this view to varying degrees, but few allow significant sem...

We describe an s-expression based syntax-extension framework much like Scheme macros, with a key additional facility: the ability to define static semantics, such as type systems or program analysis, for the new, user-defined forms or embedded languages, thus allowing us to construct “towers ” of language levels. In addition, the static semantics of the languages at two adjacent levels in the tower can be connected, allowing improved reasoning power at a higher (and perhaps more restricted) level to be reflected down to the static semantics of the language level below. We demonstrate our system by designing macros for an assembly language, together with some example static analyses (termination analysis, type inference and control-flow analysis).

Lisp is well known for its metacircular definitions. They differ by their intent (what they want to prove), their means (what linguistic features are allowed for the definition) and by their scope (what linguistic features are described). This paper provides a new metacircular definition for a complete Lisp system including traditionally neglected features such as cons, read, print and error. The programming style adopted for this interpreter is inspired both by denotational semantics and its continuation passing style (to explain continuation handling) and by the object oriented paradigm as highlighted by typedriven generic functions. The resulting interpreter lessens the number of primitives it uses to only eight: car, cdr, rplaca, rplacd, eq, read-char, write-char and end, while still providing Scheme-like essential capabilities (less arithmetic). The overall size is near 500 lines of fully encapsulated code that, if efficiency is not the main requirement, can be easily turned into...