Lua-An Extensible Extension Language

@article{Ierusalimschy1996LuaAnEE,
  title={Lua-An Extensible Extension Language},
  author={Roberto Ierusalimschy and Luiz Henrique de Figueiredo and Waldemar Celes Filho},
  journal={Softw. Pract. Exp.},
  year={1996},
  volume={26},
  pages={635-652}
}
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 objectoriented facilities, such as methods with dynamic dispatching. Lua presents a mechanism offallbacks that allows programmers to extend the semantics of the language in some unconventional… 
Exploring Lua for Concurrent Programming
TLDR
This paper works with some of Lua's facilities to explore a model for concurrent programming based on user threads and message passing, and presents a library developed to implement it, along with results of a performance evaluation.
Dynamic applications from the ground up
TLDR
This paper explores fully dynamic applications in Haskell where the static core is minimal and code is hot swappable, and illustrates both benefits in detail at the example of a novel embedded DSL for editor interfaces.
An Infrastructure for Development of Dynamically Adaptable Distributed Components
TLDR
This paper presents an infrastructure that uses an interpreted language to provide simple but powerful features that enable coarse and fine-grained adaptations in component-based systems, using the CORBA Component Model (CCM) as a basis.
Closures in Lua
First-class functions are a very powerful language construct and a fundamental feature in functional languages. However, few procedural languages support this feature, due to their stack-based
Silmaril, A Functional Language for Distributed Parallel Evaluation
TLDR
Formal program syntax, evaluation semantics and typing rules are presented, along with examples of the networked revision-control system and introspective capabilities, for a modern high-level language for implicit parallel distributed computing.
LuaInterface: Scripting the .NET CLR with Lua
TLDR
LuaInterface is a library for scripting the .NET CLR with Lua, a bridge between the Lua interpreter and the CLR, which gives Lua the capabilities of a full CLS consumer.
A Dynamic Approach to Combine Components and Aspects
In this paper we discuss the use of a dynamic approach to combine components and aspects in order to form a CORBA-based application. We use AspectLua, an extension of an interpreted and dynamically
The Delta Dynamic Object-Oriented Programming Language
TLDR
The Delta language exhibits dynamic typing not only for typical program variables, but also for object instances, meaning that class types appear always in the form of first-class values called prototypes, enabling instance creation through programmer-defined factory methods.
A Lua-based AOP infrastructure
TLDR
An aspect-oriented infrastructure to handle dynamic AOP based on the Lua language, composed of AspectLua, a Lua extension that allows the declaration of aspects, and a meta-object protocol that unifies the introspective and reflective mechanisms provided by Lua.
...
1
2
3
4
5
...

References

SHOWING 1-10 OF 37 REFERENCES
Libscheme: scheme as a C library
TLDR
The libscheme library makes the Scheme language available as a C library, which is portable to any system that has an ANSI C compiler and to which Hans Boehm's popular conservative garbage collector has been ported.
Tcl: An Embeddable Command Language
TLDR
Tel is an interpreter for a tool command language that is embedded in tools (such as editors, debuggers, etc.) as the basic command interpreter and provides a parser for a simple textual command language and a C interface that tools use to augment the built-in commands with tool-specific commands.
A scheme for little languages in interactive graphics
TLDR
The approach of reusing and extending the same core language and interpreter for a variety of little languages is the extension language approach.
An Introduction to Python for UNIX/C Programmers
Python is an interpreted, object-oriented language suitable for many purposes. It has a clear, intuitive syntax, powerful high-level data structures, and a flexible dynamic type system. Python can be
TC: An Efficient Implementation of the Tcl Language
TLDR
This paper describes a design for a faster system that maintains Tcl semantics, including its C callout mechanism, and focuses on a method for caching the parsed representation for data values, and lazily converting to strings on demand.
Self: The power of simplicity
TLDR
Because Self does not distinguish state from behavior, it narrows the gaps between ordinary objects, procedures, and closures and offers new insights into object-oriented computation.
A new architecture for the implementation of scripting languages
TLDR
This work proposes an alternate architecture where the language is translated into the dynamic language Scheme, and the resulting VHLL, Rush, provides high-level features such as automatic type conversion and production rules.
A modular verifiable exception handling mechanism
TLDR
This paper presents the syntactic extensions for embedding the replacement model into Algol 68 and its operational semantics and an axiomatic semantic definition for the model can be found in [27].
IUP/LED: A Portable User Interface Development Tool
TLDR
The design and implementation of IUPLED, a portable user interface toolkit that is designed for rapid prototyping and modification, to provide a look-and-feel appropriate to a specific computing environment, is easily expanded to support new interface developments, and supports an abstract layout model are described.
The awk programming language
TLDR
The AWK Lanaguage, an Assembler and Interpreter for Drawing Graphs, and AWK as a Language, a guide to computing with AWK and its applications.
...
1
2
3
4
...