Lua

Despite its simplicity, the scripting language Lua [1] offers a remarkable potential, primarily because of a few "Meta Mechanisms" [2] not found in other languages.

The following pages give a brief overview of Lua and document the author's activities with respect to an evaluation of that language in the context of his Ph.D. thesis.

Please, also consider my "Hints for Reading" and the "List of Recent Changes".

Overview

The list of topics given below directly guides you to the desired information - just click on a topic of your choice:

• Lua in brief - a brief description of the language and some important extensions
• Distributions - Lua, TkLua, LuaSockets compiled for Win32 systems
• Acquainting - a systematic approach to Lua programming
• Modules - scripts for basic Lua functions
• Examples - simple and less simple Lua and TkLua programming examples
• Applications - stand-alone applications written in Lua/TkLua/LuaSocket
• Miscellaneous - additional Lua stuff
   

Lua in brief

Development of Lua [1] began in 1993 by Roberto Ierusalimschy, Waldemar Celes and Luiz Henrique de Figueiredo at TeCGraf, the "Computer Graphics Technology Group" of "Departamento de Informática" (DI) at the "Pontifícia Universidade Católica do Rio de Janeiro" (PUC-Rio)[2]. Originally, Lua started up as a data description language with the intention to simplify the construction of parameter files for numerical simulations - meanwhile, it has become a generally applicable scripting language.

Lua uses a procedural syntax with comfortable mechanisms to describe data by means of associative arrays ("tables"). Data types are "dynamically" bound: while "variables" don't have a fixed type associated to them, "values" have. Prior to its interpretation by a "virtual machine" (VM), Lua source code will be compiled into an intermediate "byte code" - either explicitly using a Lua compiler or implicitly at run-time. Memory management is performed by the run-time system itself, an automatic garbage collection removes values from memory as soon as they are no longer in use.

A few "Meta Mechanisms" allow the implementation of mechanisms, which the Lua designers deliberately decided not to provide. E.g., while the language itself lacks important details of object orientation (such as single or multiple inheritance), these can be easily added with a few Lua statements. Lua designers call this feature "extensible semantics".

Lua has been primarily designed as an "extension and configuration language" and is foreseen to be integrated into a C/C++ application. It has been implemented in ANSI-C as a set of separately loadable libraries and can be easily ported to new platforms. An explicit C API (application programmers interface) allows the smooth interaction between Lua statements and objects or functions of a run-time environment. Nevertheless, by means of a simple shell application it is also possible to run "stand-alone" scripts.

The Lua licensing conditions [3] allow the utilization of Lua free of charge even for commercial applications.

A final note on the name "Lua": "Lua" means "moon" in portuguese - an allusion to the fact that the language is a successor of "Sol" (Simple Object Language), the portuguese word for "sun".

Important Extensions

Apart from the language itself, there are a number of important extensions such as:

• tolua [12]
  based on the "canonicalized" form of a C/C++ header file, tolua automatically generates any "glue" code required to access C/C++ constants, variables, functions, classes and methods from within Lua scripts;

• TkLua [13,14]
  allows the utilization of Tk widgets (and Tcl commands in general) from within Lua programs. Almost all Tk features are available for Lua programmers - in a (compared to Tcl itself) much more comfortable manner;

• LuaSocket [15]
  extends Lua with a number of important IPv4 functions (DNS, TCP and UDP) and some higher-level protocols (SMTP, HTTP & FTP).

References