Natural semantics is a formalism used for specifying both semantics and implementations of programming languages. Until recently, no practical implementation of the formalism existed. We have defined the Relational Meta-Language, RML, as an executable specification language for natural semantics. After a brief outline of the language, we describe the compilation strategy used by our rml2c compiler: transformations are applied to minimize non-determinism, and a continuation-passing style form is produced and simplified. Finally the CPS is emitted as low-level C code, using an efficient technique for implementing tailcalls. We also present performance measurements that support our choice of compilation strategy.

RML is a programming language intended for the implementation of Natural Semantics specifications. The basic procedural elements are relations: many-to-many mappings defined by a number of axioms or inference rules. It has control flow, logical variables and (explicit) unification as in Prolog; from ML it borrows a polymorphic type system, data structures, and pattern matching; a facility for separatelycompilable modules also exists. A simple prototype compiler, based on translating RML to Continuation-Passing Style and then to C, has been implemented. Benchmarks indicate that this compiler generates code that is several orders of magnitude faster than Typol, and two times faster than standard Prolog compilers.

Abstract. This paper describes the design and implementation of a language for specifying the semantics of an instruction set, along with a run-time system to support the static analysis of executables written in that instruction set. The work advances the state of the art by creating multiple analysis phases from a specification of the concrete operational semantics of the language to be analyzed. 1

Traditional database management systems perform updates-in-place and use logs and periodic checkpointing to efficiently achieve atomicity and durability. In this Thesis we shall present a different method, Shades, for achieving atomicity and durability using a copy-on-write policy instead of updates-in-place. We shall also present index structures and the implementation of Shines, a persistent functional programming language, built on top of Shades. Shades includes real-time generational garbage collection. Real-timeness is achieved by collecting only a small part, a generation, of the database at a time. Contrary to previously presented persistent garbage collection algorithms, Shades has no need to maintain metadata (remembered sets) of intra-generation pointers on disk since the metadata can be reconstructed during recovery. This considerably reduces the amount of disk writing. In conjunction with aggressive commit grouping, efficient index structures, a design specialized to a main memory environment, and a carefully crafted implementation of Shines, we have achieved surprisingly high performance, handsomely beating commercial database management systems.

1 DML, the Denotational Meta Language, is a specification language and a compiler generation tool for producing practical and efficient compilers from Denotational Semantics specifications. This means that code emitted from generated compilers should be product quality, and that generated compilers should have reasonable compilation speed, and interface well with standard frontends and back-ends. To achieve this goal, the DML system contains two main contributions compared to previous work in this area: (1) a general algorithm for producing efficient quadruple code from continuation semantics of Algol-like languages, and (2) enhancements in the DML specification language with BNF rules for abstract syntax declarations and "semantic brackets" [| ... |] with in-line concrete syntax and pattern matching for readable and concise semantic equations. Generated quadruple code is fed into a standard optimizing back-end to obtain high quality target code. The DML system generates efficient com...

A new compilation technique for left-linear term rewriting systems is presented, where rewrite rules are transformed into so-called minimal rewrite rules. These minimal rules have such a simple form that they can be viewed as instructions for an abstract rewriting machine (ARM).

In this paper, we show how pattern matching can be seen to arise from a proof term assignment for the focused sequent calculus. This use of the Curry-Howard correspondence allows us to give a novel coverage checking algorithm, and makes it possible to give a rigorous correctness proof for the classical pattern compilation strategy of building decision trees via matrices of patterns. Categories and Subject Descriptors F.4.1 [Mathematical Logic]:

This lecture discusses several kinds of interpreters for a simple functional programming language. 1

1.1 Architecture.............................. 1 1.2 Rewriting before pattern matching................. 1 1.3 Sketch of code idioms to emit.................... 2