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
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
|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
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
|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
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
Functional Reactive Programming in Scheme
|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.
|Boundaries are everywhere in languages, both the design and
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)