Abstract. Powerful, safe macro systems allow programs to be programatically constructed by the user at compile-time. Such systems have traditionally been largely confined to LISP-like languages and their successors. In this paper we describe and compare two modern, dynamically typed languages Converge and Metalua, which both have macro-like systems. We show how, in different ways, they build upon traditional macro systems to explore new ways of constructing programs. 1

The popularization of multi-core processors and of technologies such as hyper-threading demonstrates a fundamental change in the way processors have been evolving and also increases interest in concurrent programming, particularly as a means to improve software performance. However, concurrent programming is still considered complex, mostly due to difficulties in using the available programming models, which have been subject to recurring criticism. The increased interest in concurrency and the lack of proper models to support it stimulates the development of proposals aimed at providing alternative models for concurrent programming. In this paper, we explore some of Lua’s facilities to devise such a model, based on user threads and message passing. We also demonstrate why Lua was particularly well suited for this objective, describe the main characteristics of our model and present a library developed to implement it, along with results of a performance evaluation.

Dynamic scripting languages offer programmers increased flexibility by allowing properties of programs to be defined at run-time. Typically, program execution begins with an interpreter where type checks are implemented using conditional statements. Recent JIT compilers have begun removing run-time checks by specializing native code to program properties discovered at JIT time. This paper presents a novel intermediate representation for scripting languages that explicitly encodes types of variables. The dynamic representation is a flow graph, where each node is a specialized virtual instruction and each edge directs program flow based on control and type changes in the program. The interpreter thus performs specialized execution of whole programs. We present techniques for the efficient interpretation of our representation showing speedups of greater than 2x overstaticinterpretation, with an average speedup of approximately 1.3x. 1.

Abstract. Lua is a scripting language used in many industrial applications, with an emphasis on embedded systems and games. Two key points in the design of the language that led to its widely adoption are flexibility and small size. To achieve these two conflicting goals, the design emphasizes the use of few but powerful mechanisms, such as first-class functions, associative arrays, coroutines, and reflexive capabilities. As a consequence of this design, although Lua is primarily a procedural language, it is frequently used in several different programming paradigms, such as functional, object-oriented, goal-oriented, and concurrent programming, and also for data description. In this paper we discuss what mechanisms Lua features to achieve its flexibility and how programmers use them for different paradigms. 1

The rich new terrains offered by computer music invite the exploration of new techniques to compose within them. The computational nature of the medium has suggested algorithmic approaches to composition in the form of generative musical structure at the note level and above, and audio signal processing at the level of individual samples. In the region between these levels, the domain of microsound, we may wish to investigate the musical potential of sonic particles that interrelate both signal processing and generative structure. In this thesis I present a software platform (‘Vessel’) for the exploration of such potential. In particular, a solution to the efficient scheduling of interleaved sound synthesis and algorithmic control with sample accuracy is expounded. The formal foundations, design and implementation are described, the project is contrasted with existing work, and avenues for musical application and future exploration are proposed.

Abstract. Mobile phones are increasingly able to read auto-id labels, such as barcodes or RFID tags. As virtually all consumer products sold today are equipped with such a label, this opens the possibility for a wide range of novel digital services building on physical products. In this paper, we discuss the problems that arise when such novel applications are deployed and present a Browser for the Internet of Things (BIT), which facilitates the development of such consumer services on the mobile phone platform. 1

Dynamic languages are becoming increasingly popular for different software development scenarios such as Web engineering, rapid prototyping, or the construction of applications that require runtime adaptiveness. These languages are built on the idea of supporting reasoning about (and customizing) program structure, behaviour and environment at runtime. The dynamism offered by dynamic languages is, however, counteracted by two main limitations: no early type error detection and fewer opportunities for compiler optimizations. To obtain the benefits of both dynamically and statically typed languages, we have designed the StaDyn programming language that provides both approaches. StaDyn keeps gathering type information at compile time, even when dynamic variables are used. This type information is used to offer early type error detection, direct interoperation between static and dynamic code, and better runtime performance. Following the Separation of Concerns principle, it is possible to customize the trade-off between runtime flexibility of dynamic typing, and safety, performance and robustness of static typing. A runtime performance

NOTICE: This is the author’s version of a work accepted for publication in The

This paper presents Emerson, a new programming system for scripting objects in user-extensible virtual worlds such as Second Life, Active Worlds, Open Wonderland, etc. Emerson’s primary goal is to make it easy for novice programmers to write and deploy interesting applications. Scripting applications for these worlds is difficult due to two characteristics: the worlds must scale to millions of users and are therefore distributed, and there is no central authority or design so interaction is mostly between mutually untrusting applications. To simplify scripting for novices, Emerson employs two abstractions: multi-presencing and execution sandboxes. Multi-presencing allows a single program to centrally control what seem to be many distributed geometric objects. Execution sandboxes allow safely running application code provided by another object, borrowing the execution and deployment model of modern web applications. Emerson itself is implemented as a scripting plugin for the Sirikata open source virtual world platform. We evaluate the benefits of its design by describing several application examples. Through these examples, we explore the interactions between sandboxing and multi-presencing as well as their implications and discuss potential future authentication mechanisms that would make secure in-world application development more accessible.