. A trend in current research is towards component-based systems, where applications are built by combining re-usable fragments or components. In this paper we argue the case for building programming languages from components. We describe Vanilla, a component-based architecture for language tools. The core of Vanilla is a set of components, each implementing the type checking and behaviour of a single language feature, which are integrated within a well-structured framework to provide a programming language interpreter. Features may be extensively re-used across a variety of languages, allowing rapid prototyping and simplifying the exploration of new constructs. We describe the design and implementation of the system, and draw some general conclusions from the experience of building with components. Subject areas: language design and implementation; frameworks. Introduction The move towards component-based design throughout software engineering is an encouraging trend, on...

In a recent paper, Launchbury, Lewis, and Cook observe that some Haskell applications could benefit from a combinator mfix for expressing recursion over monadic types. We investigate three possible definitions of mfix and implement them in Haskell. Like traditional fixpoint operators, there are two approaches to the definition of mfix: an unfolding one based on mathematical semantics, and an updating one based on operational semantics. The two definitions are equivalent in pure calculi but have different behaviors when used within monads. The unfolding version can be easily defined in Haskell if one restricts fixpoints to function types. The updating version is much more challenging to define in Haskell despite the fact that its definition is straightforward in Scheme. After studying the Scheme definition in detail, we mirror it in Haskell using the primitive unsafePerformIO. The resulting definition of mfix appears to work well but proves to be unsafe, in the sense that i...

ML provides unusually powerful mechanisms for building programs from

Abstract Analysa is a problem-solving environment (PSE) for partial differential equations (PDE) in two or three dimensions using the language of variational formulations. It uses Scheme as a scripting language, with numerous libraries incorporated automatically. Part of the novelty in Analysa is that it allows one to define arbitrary variational forms, and it provides a notation for the action of these forms. The forms can have an arbitrary number of variables, and the resulting forms are evaluated efficiently both in terms of computation and storage. Arbitrary order piecewise polynomial spaces can be specified. Contents 1 Introduction 3 2 Poisson's

. This paper reports on results concerning the combination of non-standard semantics via interpreters. We define what a semantics combination means and identify under which conditions a combination can be realized by computer programs (robustness, safely combinable). We develop the underlying mathematical theory and examine the meaning of several non-standard interpreter towers. Our results suggest a technique for the implementation of a certain class of programming language dialects by composing a hierarchy of non-standard interpreters. 1 Introduction The definition of programming language semantics from simpler, more elementary parts is an intriguing question [6, 11, 17, 18]. This paper reports on new results concerning the combination of semantics via non-standard interpreters. Instead of using the familiar tower of interpreters [13] for implementing the standard semantics of a programming language, we generalize this idea to implement the non-standard semantics of a programming la...

In writing this paper we had two goals. First, to promote MetaML, a programming language for writing staged programs, and second, to demonstrate that staging a program can have significant benefits. We do this by example: the derivation of an executable compiler for a small language. We derive the compiler in a rigorous fashion from a semantic description of the language. This is done by staging a denotational semantics, expressed as a monadic interpreter. The compiler is a program generator, taking a program in the source language "a while-program" as input and producing an ML program as target. The ML program produced is in a restricted subset of ML over which the programmer has complete control. It is encapsulated in a special data-structure called code. The meta-programming capabilities of MetaML allow this data-structure to be directly executed "run-time code generation", or to be analysed. We illustrate this analysis of generated code to build a source to source transf...

Some in the aspect-oriented community view a programming language as aspect-oriented only if it allows programmers to perfectly eliminate scattering and tangling. That is, languages that do not allow programmers to have maximal quantification and perfect obliviousness are not viewed as aspect-oriented. On the other hand, some detractors of aspect-oriented software development view maximal quantification and perfect obliviousness as causing problems, such as difficulties in reasoning or maintenance. Both views ignore good language design and engineering practice, which suggests trying to simultaneously optimize for several goals. That is, designers of aspect-oriented languages that are intended for wide use should be prepared to compromise quantification and obliviousness to some (small) extent, if doing so helps programmers solve other problems. Indeed, balancing competing requirements is an essential part of engineering. Simultaneously optimizing for several language design goals becomes possible when one views these goals, such as minimizing scattering and tangling, not as all-or-nothing predicates, but as measures on a continuous scale. Since most language design goals will only be partially met, it seems best to call them “concerns.”

Build your own probability monads Probability is often counter-intuitive, and it always involves a great deal of math. This is unfortunate, because many applications in robotics and AI increasingly rely on probability theory. We introduce a modular toolkit for constructing probability monads, and show that it can be used for everything from discrete distributions to weighted particle filtering. This modular approach allows us to present a single, easy-to-use API for working with many kinds of probability distributions. Our toolkit combines several existing components (the list monad, the Rand monad, and the MaybeT monad transformer), with a stripped down version of WriterT Prob, and a new monad for sequential Monte Carlo sampling. Using these components, we show that MaybeT can be used to implement Bayes ’ theorem. We also show how to implement a monad for weighted particle filtering.

Reflection has a long history of dealing about some aspects of software components. In this short position paper, we compare and contrast reflection and aspect-oriented programming. Whilst reflection has recently focused on very specific aspects of software components, namely implementational usually segregated among structural (representation) and behavioral (execution) aspects, aspect-oriented programming wishes to broaden the spectrum of attributes of software taken into account. On the other hand, weaving the aspects into a coherent and faithful implementation of their prescriptions is by nature a reflective process which can be put into the hand of aspect-oriented programmers using reflection. Finally, a link can be made between aspect-oriented programming and the underinvestigated area of declarative reflection. 1 Context During the last fifteen years, we have been involved in research on reflection in programming languages. Our contributions encompass: 1. object-orien...

An object-oriented formal specification workbench is proposed for defining the syntax and semantics of programming languages, using which the formal properties of different languages can be elaborated and analyzed. Our specification approach is an object-oriented representation structured around a denotational semantics methodology, which abstracts out various common details so that formal syntax and semantics can be defined elegantly. Specific details can be inherited and specialized in defining the semantics of various programming languages, and the reusability and modifiability of many programming languages features can be manifested across language paradigms. Furthermore, prototype implementations for these languages may be automatically developed from the formal specifications, providing a mechanism for compiler/interpreter reuse at the specification level.