Lightweight Languages 2003 Abstracts

ACME - Toward a LL Testing Framework for Large Distributed Systems
Dana Moore and Bill Wright
Autonomous Agent Systems have proven difficult to instrument, monitor, control and test. Unit testing strategies are of little help, as they tend to stress functional aspects of a system rather than modal aspects and test at too low a level (the unit rather than the system). Further, emergent behaviours, indeterminacy, and the loose coupling of system elements often obscure the system's attributes. Absent specific inclusion in the system design of features that provide such specific capabilities, developers have little recourse to understand the systems they build. In this paper we describe ACME, a parallel agent system for testing used in UltraLog, a DARPA effort aimed at creating an ultra-survivable multi-agent society. We describe the motivation, architecture, implementation detail for a comprehensive testing system, and suggest a path for other MAS projects to improve testing and validation of their systems. Finally, we discuss the need for ad hoc logic changes in a running MAS, an instant messaging strategy for conversing with the society (including facilities for AliceBot and Jabber). We describe the use of Python, and Ruby in the system and summarize the benefits and lessons learned.

Interactive Web Programming using WASH/CGI
Matthias Neubauer

Many programming languages commonly used for interactive Web programming do not help the programmer to solve her problems. Common pitfalls are the manual simulation of session management by URL rewriting, the manual administration of control between different Web scripts by simple string references, the transmission and verification of all types of user input values in the form of strings, the manipulation of XHTML fragments as strings, the disregard of common browser navigation functionality, and many more.

WASH/CGI is a family of four lightweight languages specifically designed to tackle the different aspects of interactive Web programming with greater ease by dealing with such problems internally instead of putting all the burden on the programmer. The WASH/CGI language family is embedded into the strongly typed, purely functional programming language Haskell. The use of Haskell provides application specific typing guarantees through Haskell's type system. Additionally, experienced Web programmers obtain the freedom to use concepts of a fully-fledged and modern general purpose programming language as well.

The document language provides the means to construct parameterized XHTML fragments and forms in a type-safe manner ensuring the quasi-validity of all generated documents at compile time.

The session language allows the programmer to write complete interactive Web programs by providing the session management transparently. Its abstractions help to compose XHTML fragments and XHTML forms and to structure them into different user interactions.

The widget language serves as glue between the different interaction steps of a Web program. It guarantees that an interaction cannot be continued unless all inputs are validated.

The persistence language provides an interface to an abstract data type for handling server side as well as client side shared state that can persist between several different Web sessions.

The talk will give an brief overview over the different WASH/CGI languages. Accompanying examples will demonstrate the advantages of developing Web programs using WASH/CGI compared to working with other, more heavyweight Web programming languages.

XS: Lisp on Lego MindStorms
Taiichi Yuasa
We present a Lisp system XS which is designed to control RCX blocks of the Lego MindStorms Robotics Invention System. Unlike previous Lisp/Scheme implementations for the MindStorms, the evaluator of XS runs autonomously on RCX, equipped with automatic garbage collection. It communicates with the front-end system on a PC, to provide an interactive programming environment with features such as backtrace, function trace, and terminal interrupt. The evaluator supports a language based on Lisp/Scheme, extended with functionality for interfacing with RIS devices such as motors and various sensors. It also supports mechanisms such as event synchronization and asynchronous event handlers for controlling robots built on top of RIS.

Bluespec, Language Support for Next-Generation Hardware Design
Rishiyur S. Nikhil
There is a looming crisis in chip design. Verilog and VHDL, the current Hardware Description Languages, are not up to the task of managing the next level of complexity. Functional logic errors account for 43% of all ASIC respins. We need to design at a higher level of abstraction and we need better formal semantics to assure correctness. We will describe how we are addressing this problem with Bluespec. Bluespec's formal semantics are based on Term Rewriting Systems and Modular Composition. Bluespec incorporates high-level programming features such as polymorphism, first-class objects and higher-order functions, in a way that avoids the "synthesizability barrier" faced by other "behavioral synthesis" approaches.

The Virtual Machine of Lua
Roberto Ierusalimschy
Lua is a scripting language with a growing number of users, mainly in the game industry. Its main features are lightness, portability, efficiency, and easiness to embed. In this talk we will give an overview of the new virtual machine of Lua (version 5.0). We will describe how the machine uses a register-based architecture (instead of the conventional stack-based approach used by most interpreters) and how it optimizes the use of (associative) tables as arrays. These changes allowed a speed up of ~30% in the new version of the language.

Embedding an interpreted language using higher-order functions and types
Norman Ramsey
Using an embedded, interpreted language to control a complicated application can have significant software-engineering benefits. But existing interpreters are designed for embedding into C code. To embed an interpreter into a different language requires a suitable API. Lua-ML is a new API that uses higher-order functions and types. The API exploits higher-order functions and types to reduce the amount of glue code needed to use an embedded interpreter. Whereas embedding in C requires a special-purpose ``glue function'' for every function to be embedded, embedding in Lua-ML requires only a description of each function's type. Lua-ML also makes it easy to define a Lua function whose behavior depends on the number and types of its arguments.

Functional Reactive Programming in Scheme
Gregory Cooper
Functional Reactive Programming (FRP) extends a language with time-varying values, or signals. In this talk, we present Father Time (FrTime), a Scheme-based implementation of FRP with several novel features, including support for distributing signals over a network. We demonstrate the system, which runs in the DrScheme interactive programming environment, and illustrate the language's expressive power with a few examples.

Joint work with Shriram Krishnamurthi.

Dan Sugalski
Boundaries are everywhere in languages, both the design and the implementation.

They mark where guarantees are made, promises are kept (and broken), lines can't be crossed, costs paid, and paradigms shifted. They define the shape of a program, the feel of a language, and the job of the person who makes it all work.

Boundaries can be explicit, defined by APIs and promises, or implicit, defined by behaviour. They're often not thought about, or thought too little about, and far too often they are found after the fact or set by convention, rather than by thought beforehand. Good boundaries make parts of a language or language engine pleasant to use, bad ones make it nasty.

Boundaries are especially important to lightweight (or little, whichever we are this year) languages--they so rarely stand alone, far more often embedding other langugages, or in turn embedded in other programs, and are more often crossing boundaries.

This talk is about designing and using boundaries (no surprise) with an emphasis on the practical. (What can I say, I'm an implementor, not a language designer)

Jeremy Hylton
Last modified: Mon Nov 3 00:13:39 EST 2003