Roberto Ierusalimschy

Lua—an extensible extension language

This paper describes Lua, a language for extending applications. Lua combines procedural features with powerful data description facilities, by using a simple, yet powerful, mechanism of tables . This mechanism implements the concepts of records, arrays and recursive data types (pointers), and adds some object‐oriented facilities, such as methods with dynamic dispatching.

The evolution of Lua

We report on the birth and evolution of Lua and discuss how it moved from a simple configuration language to a versatile, widely used language that supports extensible semantics, anonymous functions, full lexical scoping, proper tail calls, and coroutines.

Application integration: constructing composite applications from interactive components

Creating new applications by integrating user interface and application components is a relatively new idea which is currently of wide interest. A significant part of this problem is clearly defining the separation between user interface and application components. This paper proposes a new design methodology based on the concept of an abstract data view (ADV), a structuring method which cleanly defines this separation. A number of examples of composite interactive documents, ones which could contain several different user interfaces with entities such as text, calculations, drawings and possibly even multi‐media presentations, illustrate the ADV concept. These examples lead naturally to the introduction of the concept of hole, a user interface area in a composite interactive document which is managed by an external program, and uses ADVs. Prototypes of a number of systems supporting ADVs and holes are currently running in our laboratory.

Dynamic component gluing across different componentware systems

We present a model to support dynamic gluing of components from different componentware systems, such as CORBA, COM and Java. This model adopts a dynamic composition approach combined to the interactive facilities offered by an interpreted language. Based on this model, we define a common design for the implementation of bindings between glue languages and component systems. The proposed design provides a natural way to create dynamic bridges between different component systems. We also describe the LuaOrb system, an implementation of the proposed model that binds the interpreted language Lua to Java, CORBA and COM. With LuaOrb, Lua acts as a unifying glue language, wherein we can write code that freely use and mix components from these three component systems.

Passing a language through the eye of a needle

How the embeddability of Lua impacted its design.

Safe system-level concurrency on resource-constrained nodes

Despite the continuous research to facilitate WSNs development, most safety analysis and mitigation efforts in concurrency are still left to developers, who must manage synchronization and shared memory explicitly. In this paper, we present a system language that ensures safe concurrency by handling threats at compile time, rather than at runtime. Based on the synchronous programming model, our design allows for a simple reasoning about concurrency that enables compile-time analysis resulting in deterministic and memory-safe programs. As a trade-off, our design imposes limitations on the language expressiveness, such as doing computationally-intensive operations and meeting hard real-time responsiveness. To show that the achieved expressiveness and responsiveness is sufficient for a wide range of WSN applications, we implement widespread network protocols and the CC2420 radio driver. The implementations show a reduction in source code size, with a penalty of memory increase below 10% in comparison to nesC. Overall, we ensure safety properties for programs relying on high-level control abstractions that also lead to concise and readable code.

A parsing machine for PEGs

Parsing Expression Grammar (PEG) is a recognition-based foundation for describing syntax that renewed interest in top-down parsing approaches. Generally, the implementation of PEGs is based on a recursive-descent parser, or uses a memoization algorithm. We present a new approach for implementing PEGs, based on a virtual parsing machine, which is more suitable for pattern matching. Each PEG has a corresponding program that is executed by the parsing machine, and new programs are dynamically created and composed. The virtual machine is embedded in a scripting language and used by a patternmatching tool. We give an operational semantics of PEGs used for pattern matching, then describe our parsing machine and its semantics. We show how to transform PEGs to parsing machine programs, and give a correctness proof of our transformation.

ALua: flexibility for parallel programming

In this paper we present ALua, an event-driven communication mechanism for developing distributed parallel applications, based on the interpreted language Lua. We propose a dual programming model for parallel applications, where ALua acts as a gluing element, allowing precompiled program parts to run on different machines. We show, through examples, how three types of applications can benefit from the flexibility that derives from this model. We then present a study of ALuas performance, by comparing execution times of two parallel applications written in ALua with their counterparts written in PVM.

Dynamic configuration with CORBA components

Most existing support for dynamic reconfiguration assumes that component interfaces specify input and output channels. The CORBA model, however, specifically supports a client-server architecture, with component interfaces describing only the provided services. Besides, the existing bindings for CORBA, based on static stubs, impose considerable difficulties on dynamic configuration. This paper investigates the use of the interpreted language Lua as a tool for dynamic configuration of distributed applications using CORBA components.

Programming with multiple paradigms in lua

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.