Lightweight Languages 2004 Abstracts

English: The Lightest Weight Programming Language of All
Hugo Liu, Henry Lieberman
Every program tells a story. Programming, then, is the art of constructing a story about the objects in the program and what they do in various situations. Traditionally, these stories are expressed in so-called programming languages. These languages are easy for the computer to accurately convert into executable code, but are, unfortunately, difficult for people to write and understand.

In this paper, we explore the idea of using descriptions in a natural language like English as a representation for programs. While we cannot yet convert arbitrary English descriptions to fully specified code, this paper shows how we can use a reasonably expressive subset of English as a visualization tool. Simple descriptions of program objects and their behavior are converted to scaffolding (underspecified) code fragments, that can be used as feedback for the designer, and which can later be elaborated. Roughly speaking, noun phrases can be interpreted as program objects; verbs can be functions, adjectives can be properties. A surprising amount of information about program structure can be inferred by our parser from relations implicit in the linguistic structure. We refer to this phenomenon as programmatic semantics. We present a program editor, Metafor, that dynamically converts a user's stories into program code, and in a user study, participants found it useful as a brainstorming tool.

Dynamic Languages on the Common Language Runtime (CLR) - IronPython
Jim Hugunin
The goal of the Common Language Runtime (CLR) is to provide a universal virtual machine for all kinds of programming languages.  Today it runs efficient production-quality implementations of many heavy-weight statically typed and traditionally compiled programming languages.  Recent work has shown that this platform can also be an excellent target for light-weight dynamic languages with the efficient implementation of IronPython (  This talk will look at the implementation of IronPython and discuss the techniques used to implement different Python language constructs on top of the CLR.  These techniques should be generally applicable to a range of light-weight languages.  Time permitting this talk will also discuss cross-language interoperability in the CLR.  This is another area where the CLR has been very successful with heavy-weight languages and where this success can hopefully be translated to light-weight languages in the future.
Using Scheme to Develop Control Systems for a Large Telescope
Richard A. Cleis
This presentation describes implementations of Scheme at the Starfire Optical Range (SOR), an atmospheric research facility dedicated to the development of optical wavefront control technologies including adaptive optics for large telescopes capable of tracking fast objects.  Control systems were developed for the gimbals and the 3-axis secondary mirror assembly of the SOR's largest telescope, equipped with a primary mirror of 3.5 meters diameter and weighing a total of 275,000 pounds.  It will be shown how various combinations of DrScheme, MzScheme, and the Small Fast S-Expression Library were used to 1) form an interactive operation and test environment, 2) provide scheme-only initialization and configuration, 3) serve as a natural courier of s-expressions over Ethernet, and 4) provide an elegant interface to HTML Forms that permit remote control and curiously operational documentation pages.  All software tools were obtained free of charge from public internet sources and were hosted by Red Hat Linux, White Dwarf Linux, OS X, or Windows 2000, demonstrating the cross-platform versatility of Scheme.
Small programs with Zest and Marmalade
Benjamin Schroeder, John Pierce
Some of the most useful programs are small. Even many large programs start life as small ones and are then refined and expanded until they do many things.

"Zest" is a cross between a Smalltalk workspace and a Wiki. "Marmalade" is a Self-like object system written on top of Squeak Smalltalk. Both enable a direct, exploratory programming style that helps in writing small and ad-hoc programs.

We will present a few small programs written with Zest and Marmalade, as well as Zest and Marmalade themselves.
Eliza, a small strongly typed functional logic programming language
Matthias Huerlemann
This paper describes the concept of a new programming language called Eliza. Its name is inspired by the doctor chatbot originally written by Prof. Weizenbaum. The language follows four major principles: simplicity, small size, speed and power. The core language is very small. Eliza compiles to parrot intermediate code. All the functionality comes from compilable libraries which themselves can load Perl6 modules. It follows the parrot calling conventions and is fully compatible with the future Perl6 world. Eliza is a functional logic programming language. It does not support objects. I have come to the conclusion that objects would spoil the design of the language. An Eliza program implements several patterns. One of them is the producer consumer pattern like pipes supported in most UNIX shells. The behaviour is similar. Only, these pipes are inside the program, not between programs. Eliza supports backtracking which moves back and forth along the piped function calls. Eliza is a statically typed and polymorphic language which allows to have several return values at once. The inspiration for the language design comes mainly from Lisp, Prolog, Icon, Ruby, Bash, C, Haskell and Curl. Eliza has been a one man opensource research project so far. 
Continuations continued: The REST of the computation
Anton van Straaten
In this talk, I will show that despite initial appearances to the contrary, first-class continuations are in fact compatible with the REpresentational State Transfer (REST) architectural style for web applications.  I will also show that continuations can be a valuable tool for development of REST applications, removing some of the traditional restrictions on the design of these applications, without violating any REST principles.  This creates useful new architectural possibilities, making it possible to develop REST applications using the style most appropriate to each application or component.

REST is primarily a description of the architectural characteristics of many existing successful web applications, and as such, even those unfamiliar with REST will recognize the architectural style.  This talk will provide a five-minute explanation of the REST style, and put it in context.  The focus on REST is not intended to advocate it as the best or only way of developing web applications.  However, if continuations can work and provide significant benefit within the architecturally constrained style described by REST, then they can do the same for other kinds of web applications.  To paraphrase the late Frank Sinatra, "If continuations can make it there, they're gonna make it anywhere."

This talk will show how concerns about continuations, such as scalability and integration with current tools, can be addressed within an existing, proven model.  Going further, the talk will show that combining the scalable and robust design of REST-style systems with the higher-level abstraction and development convenience provided by continuations can be a major win. This combination has the potential to take a big step towards a long-sought holy grail of distributed systems: the ability to write distributed applications as though they were local applications, without sacrificing the kind of scalability or resilience which REST systems enjoy.

This talk will examine the possibilities and limitations of current academic and mainstream tools in the above respects, as well as highlighting the critical features needed in future languages and tools to best support these uses of continuations in realistic systems.
Gooze, a stream processing language
Jonathan Bachrach
We present a stream processing language, called Gooze, that's targeted towards real-time interactive multimedia installations and kiosks. Gooze provides a unified framework for the scripting of multimedia applications involving a variety of data and control such as audio, text, vectors, images, layout, and online and offline processing.  Gooze provides a natural syntax for writing streaming operations and a framework for creating streaming modules.  It also provides a meta programming level allowing for the parameterization of modules. Finally, the implementation performs a number of high level profitable optimizations.  The goal is to design and construct a practical, powerful, and extremely easy to use system.  In the past year, Gooze has been successfully used to construct a variety of interactive installations shown at the mit media lab, mit museum, dance theatre workshop nyc, nouvelle cinema festival montreal, as well as two segments of HD video content shown on the ZOOM network.  This talk will present the language by example building up a variety of live examples of audio and video applications.
Frink - A Language for Understanding the Physical World 
Alan Eliasen
Physical calculations, when implemented in most programming languages, often become an impenetrable mishmash of dimensionless numbers and implied units of measure.  Incorrectly mixing units of measure may lead to incorrect results that are difficult to detect, or may lead to catastrophic results, as evidenced in the failure of the Mars Climate Orbiter.

Frink was designed to track units of measure through all calculations, allowing the computer to perform much of the validation and bookkeeping necessary to ensure that answers are correct.  Back-of-the-envelope calculations become trivial, and more complex physical calculations become simpler to write and read, and allow transparent use of any units of measure.

Frink was also designed to be a high-level language that can control simulations, and to be a lightweight glue language that leverages the power of existing Java libraries.  To be a practical, multi-purpose language, Frink also incorporates text processing, the ability to utilize Internet-based data sources, arbitrary-precision math, object-oriented programming, design by contract, date/time mathematics, and an extensive standard library of data to streamline calculations.

This talk also discusses the difficulties and compromises necessary when creating a language that attempts to preserve standard mathematical notation.  The promise and pain of implementing a programming language in Java will also be described.  Sample programs in Frink will be demonstrated, from simple, one-line calculations, up to large, high-precision programs to calculate the next moon alignment with M.I.T.'s "Infinite Corridor."

Frink documentation may be found at:

Sponsored by Microsoft Research        Hosted by the Software Design Group at MIT CSAIL

ll4-organize at lists dot csail dot mit dot edu