A Look at Lua

Lua is a free and open-source multi-paradigm programming language released
under the MIT license. Created in 1993 by Roberto Lerusalimschy, Luiz
Henrique de Figueiredo and Waldemar Celes, Lua is a dynamically typed
language. Extremely compact (only 150KB compiled), it is primarily used
as a scripting language or an extension to another language (mainly C/C++).

What Is Lua and How Is It Used?

Lua is implemented as a library and has no “main” program. It works
only when embedded in a host client. The interpreter is a C program that
uses the Lua library to offer a standalone Lua interpreter. Rather
than provide a complex and rigid specification for a single paradigm,
Lua is intended to be extended to fit different problem types.

Being small, Lua fits on many host platforms and has been ported and
used in video games for both the PlayStation Portable and the Nintendo
DS, and it is used in larger games, such as FarCry
and World of Warcraft. The
Adobe Photoshop Lightroom photography program and the lighthttpd Web
server have incorporated Lua as well. Lua has a few advanced features,
primarily coercion, coroutines, garbage collection, first-class functions
and dynamic module loading. Because Lua is small, it includes only a few
data types. It attempts to maintain a balance between power and small size.

What's Different about Lua?

Lua is comparably as easy as Python in terms of learning how to write
code. Of the two, Lua is usually the better choice for embedded systems,
simply because it's smaller. Lua's strength is in processing strings
and tables. It handles logical equations more adeptly than Python.

For a quick hack, a Lua programmer can process complicated data more
quickly and easily
than a Python programmer can (although a Ruby programmer
can do so almost as quickly). But, for a large application that handles
many chunks of complex data, a heavier language such as Ruby or Python
may be a better choice.

There is no need to worry about different types of integers. You may
have found that the different types of integers and numbers (such as
floats, longs or doubles) can screw up the output of your program or
even make it crash if you are absent-minded. Lua uses coercion for every
integer and number type to convert it into a single type. You can add a
float, long integer or a double to any other type of integer or number
without a hitch in Lua. In contrast, doing this can cause programs written
in Python 2.4 or older versions to crash. Lua is extremely forgiving
syntactically. What if, for some reason, you are programming on an
embedded device with a four-inch wide screen? You can reduce the amount
of lines and other characters, which in turn enables easy reading of the
code to make up for the small screen.

Small is beautiful. A programmer can embed Lua into several other
languages, such as C/C++ and Java, without bloating the host language,
because Lua has a tiny API. Similar to Lisp's single data structure,
tables are the only data structuring mechanism that Lua has. This makes
tables very powerful, because with a little work, they can emulate data
structures in larger languages.

Object-oriented programming implementation is minimalistic. Lua uses
tables and functions rather than classes.

In contrast to Python, Lua does not focus on 100% backward
compatibility. Many newer releases of Lua break programs written in
previous versions. Fortunately, the Lua developers always announce what
the new versions of Lua will break.

Lua supports threading. Multiple Lua interpreters can coexist in the
same process, and each one can run independently in its own thread. This
often makes Lua desirable for multithreaded programs in embedded systems.

Installing Lua

To compile and install Lua from the source code, grab a copy of Lua
5.1 from the Lua.org Web site, and untar, configure, make and
install it:

tar -xvzf lua-5.1.1.tar.gz
cd lua-5.1.1
make xyz
make xyz install

(xyz is your platform name.)

Lua should now be installed and working. To test your install, type
lua on the command line. An interactive interpreter should appear.

Syntax

Lua is a dynamically typed language whose syntax is very similar to that
of Python and even more similar to Ruby. Line breaks do not play any
role in Lua's syntax, like that of Python or Ruby. Take, for example,
the following ugly, but valid code:

Lua supports only a few
data structures, including arrays, lists and hash tables.

The table type implements an associative array that can be indexed with
any value (similar to Python), except nil (dissimilar to Python). Nil's
goal is to be different from any other value, as well as the default value
for global variables. Nil also plays a much more important role in Lua
than None does in Python. Although tables are the only data structuring
mechanism in Lua (which may seem like a disadvantage), the table is just
as powerful as Python's dictionary and list, and it's even as powerful as Ruby's
hash. Tables are used to represent many different types of arrays, sets,
trees and several other data structures. One handy feature of tables
is to use strings as keys—for example:

x = { ["hello world!"] = "ciao world!" }
print(x["hello world!"])

When running this example, Lua outputs “ciao world!” and not
“hello
world!” as it might appear.

Comment viewing options

"There is no need to worry about different types of integers." There is no need to do that in Python either nowadays. The conversion between "regular integers" and long ones is done automagically. Take the following function:

def frac(n):
if n == 0: return 1
else: return n * frac(n - 1)

Evaluating frac(10) gives the result 3628800 while frac(30) returns 265252859812191058636308480000000L.

"You can add a float, long integer or a double to any other type of integer or number without a hitch in Lua. In contrast, doing this can cause programs written in Python 2.4 or older versions to crash." Really? I've never heard of this problem. Do you have any references?

"In contrast to Python, Lua does not focus on 100% backward compatibility." That Python would focus on 100% backward compatibility is just plain wrong. Code I've written broke when moving from version 2.4 to 2.5 due to changes in generators. This is the only time I've personally been bitten by it but every version of Python has broken something from earlier versions. AFAIU Python 3000 will break a whole lot of older Python programs.

"Unlike Python, global variables do not need to be declared." They don't need to be declared at all, not on a global level. If a function wants to access a global variable then _it_ has to declare it as global. Contrast that to the following point.

"Exactly the opposite of Python, most variables in Lua are global by default, and you must declare the variable "local" to make it a local variable rather than assuming that all variables are local." Variables in Python are local by default, which in my experience better reflect how variables are used by programmers.

The for loop is a little more complex in Python than it is in Lua, because Python needs to know the key to be able to get the key's value." It's possible to iterate over both key and value in Python as well:

h = {1:'hello', 2:'world'}
for k, v in h.iteritems():
print k, v

In general it's a good article, it shows off some interesting points in Lua. In order to make a comparison between two languages it's necessary to have very good knowledge of both languages, otherwise there's a real risk that one language is the favourite simply because the author knows that one the best. This piece definitely suffers from that.

I also believe it would have been better without the author's personal opinions on aesthetics sprinkled across the piece.