## Why Lua

In this article, I would like to discuss why you should use Lua. This all started with a message that recently popped up on the Lua mailing list regarding why isn't Lua more widely used? The answers went from randomness to lack of libraries to a variety of other things, but the one that resonated with me most was that there are fewer people who enjoy the do it yourself approach, which Lua fully embraces. I've come to think of Lua as the Arch Linux of programming languages. Which, almost by definition, means fewer people will enjoy Lua rather than more. So then why would you want to use Lua? In no particular order, here are some of the reasons why we use Lua to develop our product:

### 1. Integration with C (and C++ for that matter)

I have used a lot of languages during my short career as a programmer. Lisp, Scheme, Python, Perl, Bash, VBA, SQL, etc. etc. etc. There is no other language that I have ever used that even comes close to Lua when trying to commingle C code. The C API is so clean and so intuitive that I would argue that you could get up to speed on its use in an afternoon. Check out PIL's section on the C API if you are interested in learning more.

Why is this important? Well, for one this means that if you have an existing C (or C++) library, it is usually not very difficult to expose the API to Lua. Nor is it difficult to write a script in Lua and get something running on the C side. This also means that speed problems are rarely an issue in Lua programs. You can write something in Lua and truly rewrite it in C if it is a speed problem. It is always possible to rewrite something in C in other languages, but Lua is the only language in which I have found it easy to do so.

### 2. Speed and Simplicity

The standard Lua implementation performs extremely well compared to most other languages, even without writing anything in C. Perhaps this is because Lua uses a register based virtual machine rather than a stack based machine. Or it could simply be due to the fact that the programmers behind Lua are just very talented. Whatever the reason, you are rarely going to be overly concerned with performance when writing Lua code.

But, if you are not getting the results you would hope or expect, you can get an almost drop in replacement for the standard Lua implementation with LuaJIT. From the overview page:

LuaJIT is widely considered to be one of the fastest dynamic language implementations in existence ... with an unmatched low memory footprint: less than 125K for the VM plus less than 85K for the JIT compiler (on x86).

LuaJIT speeds can rival code written in C. And if you are still not getting the speed you want, see my 1st point above.

### 3. Education

While not necessarily a language feature, I have found that using Lua has improved my general computer science knowledge over time. For example, this writeup on the implementation of Lua 5.0 gave me a very good overview of how virtual machines are implemented. Reading the very accessible source code, while following the recommended reading order suggested by Mike Pall (Author of LuaJIT) has been eye opening as well. I don't think any of this would be possible except for the methodical manner in which Lua has evolved over time. This has allowed Lua to remain "Clean C" which means that it is easier for you to understand as a user of the language.

### 4. Functional

Lua provides you with functional programming constructs that make programming more enjoyable. Examples include anonymous functions, higher order functions, lexical closures, proper tail calls, etc. And this is not some superficial gloss applied on top of the language - it represents some of the fundamental underpinnings of the language itself. For example, all functions in Lua are values (like the number 2 or the string "ktr") - and this means that every function in Lua is anonymous. You simply attach a name to it so that you can reference it later. Thus, like Roberto describes in his book, you can reassign print with:

print = math.sin


This type of functionality also enables you to build sandboxes if you need them. If printing were a dangerous operation, you could replace it with your own print function or simply remove it from the global environment.

### 5. Everything is a Table

Everything in Lua is a table. Arrays, hashes, "modules", the global environment, etc. They are all tables. This means that you can require some module (similar to Python's import statement) and treat the resulting value just like you would any other table. In Python, you might __import__('...')' some module and then the variables of the return value would be accessed like vars(module). Not very difficult, but also not very Pythonic. In Lua, you would access the variables in that module just like any other table (module[var]). I only mention Python to highlight differences - simply showing that it may be easier to "hold Lua in your head" due to such consistencies.

This has the added benefit of allowing you to learn the full Lua syntax faster than you could in most other languages. Without needing to worry about how lists are written versus how dictionaries, packages, etc. are written, you can "assume" you already know how they are written because you only need to know the one construct.

### 6. Consistent

If you haven't figured it out already, Lua is a very consistent language. A lot of time has gone into each and every feature to make sure that it was done "just right". For example, Lua didn't have a for loop until Lua 4.0 - 7 years after the first release. This was because

while loops were more general. ... Also, we could not agree on a good syntax.

(See page 6 of this document). And since the Authors of the language have remained relatively unchanged and rather limited (the Lua team does not like to accept patches), the language has evolved somewhat slowly and quite coherently. So you know features are well planned. (However, this also means you shouldn't expect to have a lot of your pet features implemented anytime soon.)

### 7. Portable

I won't go into a lot of detail, but rest assured that Lua runs on almost everything you can think of. The code is written as "Clean ANSI C", so if you have a compliant C runtime, you will likely be able to get Lua running without much fanfare.

All in all, a very powerful, yet simple language.