Salim Benhouhou   IT Support
Lua ( /ˈluː.ə/ LOO-ə; from Portuguese: lua meaning "moon") is a lightweight multi-paradigm programming language designed as a scripting language with extensible semantics as a primary goal. Lua has a relatively simple C API compared to other scripting languages.

History

Lua was created in 1993 by Roberto Ierusalimschy, Luiz Henrique de Figueiredo, and Waldemar Celes, members of the Computer Graphics Technology Group (Tecgraf) at the Pontifical Catholic University of Rio de Janeiro, in Brazil.

From 1977 until 1992, Brazil had a policy of strong trade barriers
(called a 'market reserve') for computer hardware and software. In that
atmosphere, Tecgraf's clients could not afford, either politically or
financially, to buy customized software from abroad. Those reasons led
Tecgraf to implement from scratch the basic tools it needed.

Lua's historical 'father and mother' were data-description/configuration languages SOL (Simple Object Language) and DEL (data-entry language).
They had been independently developed at Tecgraf in 1992-1993 to add
some flexibility into two different projects (both were interactive
graphical programs for engineering applications at Petrobras
company). There was a lack of any flow control structures in SOL and
DEL, and Petrobras felt a growing need to add full programming power to
them.


In 1993, the only real contender was Tcl,
which had been explicitly designed to be embedded into applications.
However, Tcl had unfamiliar syntax, did not offer good support for data
description, and ran only on Unix platforms. We did not consider LISP or Scheme because of their unfriendly syntax. Python
was still in its infancy. In the free, do-it-yourself atmosphere that
then reigned in Tecgraf, it was quite natural that we should try to
develop our own scripting language... Because many potential users of
the language were not professional programmers, the language should
avoid cryptic syntax and semantics. The implementation of the new
language should be highly portable, because Tecgraf's clients had a very
diverse collection of computer platforms. Finally, since we expected
that other Tecgraf products would also need to embed a scripting
language, the new language should follow the example of SOL and be
provided as a library with a C API.


Lua 1.0 was designed in such a way so its object constructors, being
then slightly different from the current light and flexible style, had
incorporated data-description syntax of SOL. (Hence the name Lua — sol is Portuguese for sun; lua is moon.) Lua syntax for control structures was mostly borrowed from Modula (if, while, repeat/until), but also had taken influence from CLU (multiple assignments and multiple returns from function calls, as a simpler alternative to reference parameters or explicit pointers), C++ ("neat idea of allowing a local variable to be declared only where we need it"), SNOBOL and AWK (associative arrays). In an article published in Dr. Dobb's Journal, Lua's creators also state that Lisp and Scheme with their single, ubiquitous data structure mechanism (the list) were a major influence on their decision to develop the table as the primary data structure of Lua.

Current Lua semantics were gained mainly from Scheme:


Semantically, Lua has many similarities with Scheme, even though
these similarities are not immediately clear because the two languages
are syntactically very different. The influence of Scheme on Lua has
gradually increased during Lua's evolution: initially, Scheme was just a
language in the background, but later it became increasingly important
as a source of inspiration, especially with the introduction of
anonymous functions and full lexical scoping.


Versions of Lua prior to version 5.0 were released under a license similar to the BSD license. From version 5.0 onwards, Lua has been licensed under the MIT License.


Features

Lua is commonly described as a “multi-paradigm”
language, providing a small set of general features that can be
extended to fit different problem types, rather than providing a more
complex and rigid specification to match a single paradigm. Lua, for
instance, does not contain explicit support for inheritance, but allows it to be implemented relatively easily with metatables. Similarly, Lua allows programmers to implement namespaces, classes, and other related features using its single table implementation; first-class functions allow the employment of many powerful techniques from functional programming; and full lexical scoping allows fine-grained information hiding to enforce the principle of least privilege.

In general, Lua strives to provide flexible meta-features that can be
extended as needed, rather than supply a feature-set specific to one
programming paradigm. As a result, the base language is light — in fact, the full reference interpreter is only about 150 kB compiled — and easily adaptable to a broad range of applications.

Lua is a dynamically typed language intended for use as an extension or scripting language,
and is compact enough to fit on a variety of host platforms. It
supports only a small number of atomic data structures such as boolean values, numbers (double-precision floating point by default), and strings. Typical data structures such as arrays, sets, lists, and records can be represented using Lua’s single native data structure, the table, which is essentially a heterogeneous associative array.

Lua implements a small set of advanced features such as first-class functions, garbage collection, closures, proper tail calls, coercion (automatic conversion between string and number values at run time), coroutines (cooperative multitasking) and dynamic module loading.

By including only a minimum set of data types, Lua attempts to strike a balance between power and size.



Read More About Lua From Wikipedia
Apr 16th 2011 01:37