Presentation: Mint: A Multi-stage Extension of Java

Mint: A Multi-stage Extension of Java
(PowerPoint, PDF, view embedded)
Video recording available on vimeo.

Where: Rice University Computer Science Department, COMP 600 Graduate Seminar
When: February 8, 2010

Multi-stage programming (MSP) provides a safe way of generating code
at run-time. In mostly-functional languages like MetaOCaml, this has
been used to reduce the performance penalties of abstractions such as
loops, recursion or interpretation. The main advantage of MSP compared
to other techniques, such as string or LISP quotations, is that MSP
guarantees type safety for the generated code statically, at the time
the program is compiled.

Unfortunately, MSP is difficult to combine with imperative features
found in most mainstream languages like Java. The central problem is
“scope extrusion”, which may accidentally move variables outside the
scopes in which they are bound, leading to run-time errors in the
generated code. This problem can be prevented if code in escapes (or
“anti-quotes”) is “weakly separable”, i.e. the computational effects
occurring inside an escape that are visible from the outside do not
involve code.

We have formalized a type system, based on Lightweight Java, that uses
weak separability to prevent scope extrusion, and we have proved that
the type system is sound. We have also developed an implementation
called Mint to demonstrate the expressivity of the type system and the
performance benefits MSP can provide in an imperative setting. Since
our implementation extends the Java language, our work is accessible
to mainstream programmers.

This talk is based on work done in collaboration with Edwin Westbrook,
Jun Inoue, Yilong Yao, Tamer Abdelatif, and Walid Taha. A paper titled
“Mint: Java Multi-stage Programming Using Weak Separability” has been
accepted for publication in the Proceedings of the 2010 ACM SIGPLAN
Conference on Programming Language Design and Implementation (PLDI
2010).