lua-users home
lua-l archive

[Date Prev][Date Next][Thread Prev][Thread Next] [Date Index] [Thread Index] 

Roberto Ierusalimschy wrote: > I do not think I am unbiased enough to present the best arguments. I guess we need a (completely biased) Lua PR department then? :-) (no, I'm not volunteering) Ok, here's my list of arguments why Lua would be a good choice for a cell phone VM: - Lua is small: the Lua interpreter easily fits in under 100 kilobytes including the base libraries. Cell phones are often very memory limited -- every kilobyte saved counts. It's practically hopeless to try to strip the non-essential parts from larger runtimes (Python, Java -- you name it) without severely limiting their functionality (J2ME anyone?). And you'll still not be able to match Lua's small footprint. One really cannot afford a "batteries-included" and all-memory-you-can-eat VM on a cell phone. Minimal memory use is important even for smartphones with more generous resource limits. Their CPU caches are usually small and memory access is rather slow compared to desktop CPUs. - Lua is fast: independent benchmarks show that Lua is often amongst the fastest interpreted dynamic languages. The Lua interpreter has been extensively tuned for high performance. The call-out mechanism to C is one of the fastest, too (compare to JNI). It has been shown that Lua can be compiled to machine code with a JIT compiler (x86 only right now) for even better performance at minimal cost (30% larger footprint). Given how underpowered many cell phone CPUs are, this means that Lua could be used to supplant even more tasks usually delegated only to systems programming languages (i.e. C). [Disclaimer: I wrote LuaJIT.] - Extending Lua is easy: Lua has been designed to work together with C. The Lua VM offers a small, yet flexible C API. Binding to C libraries is the forte of Lua. Often enough a few lines suffice. Even beginners can write a binding in minutes without studying huge manuals. There are plenty of automatic binding generators for larger tasks, too. Compared to other language's binding mechanisms, Lua's C API effectively provides a shield between the internals of the Lua VM and the outer world. One does not have to care about internal structures of the Lua VM or even the garbage collector (how many refcounting bugs do your Python bindings have?). - Embedding Lua is easy: the Lua core uses zero static data. All C APIs require a single opaque handle which carries along the complete state of the VM. Memory use is strictly contained. The Lua core does not leak memory. Even custom memory allocation functions can be used. It's easy to use multiple completely independent Lua interpreters in a single process if there should be a need. Lua needs only a handful of ANSI C library functions for operation. And even these can be further reduced. Lua has excellent portability to even the most restricted embedded environments. - Lua has an incremental GC: amongst the options for implementing a garbage collector, an incremental GC is most suitable for embedded devices. It has low latency, no additional memory cost and little implementation complexity. A traditional mark-and-sweep GC may cause lengthy pauses which are incompatible with semi-real-time requirements (imagine: "Please hold the line while we're cleaning up -- beep"). Generational GC has a much higher memory overhead and its heuristic approach to reclamation may hold on to important resources much longer than tolerable in such an environment. [It has been debated at length whether GC is an appropriate mechanism for managing memory in resource constrained devices. But manual memory management is tedious and error-prone. The benefits of GC, coupled with modern languages by far outweigh its disadvantages wrt. average memory use IMHO.] - Lua has coroutines: multitasking is desirable, even on small devices. Too often one encounters annoying limits on cell phones, e.g. one cannot open the calendar or lookup a number in the phonebook while on the phone with someone. But fully preemptive multitasking is either not supported or is considered too costly for these environments. Lua's coroutines provide a fast and memory efficient way for non-preemptive multitasking. Lua's coroutines are built-in and are independent of the capabilities of the underlying OS. Lua even happily runs on devices without an MMU. - Lua can be sandboxed: it's easy to restrict access to library functions on a function-by-function basis. Memory use as well as CPU usage can be restricted, too. This is very important for a cell phone environment. You really want to prevent any random application you've downloaded from blocking the GUI forever or silently making expensive phone calls on your behalf. Removing certain dangerous library functions or (better yet) just offering a handful of "safe" functions for use by user-written applications is easy. It's even possible to manage multiple protection domains with different privilege levels in the same Lua VM. Other VMs provide either no support for sandboxing (short of completely ripping out huge parts of their libraries) or offer only complicated and inflexible protection mechanisms. Lua can be sandboxed _in_ Lua and with standard Lua calls, providing for maximum flexibility at minimum cost. - Lua is malleable: Lua has just enough syntactic sugar and meta-mechanisms to be easily repurposed for domain specific languages (DSL). It's nice for (readable!) configuration files or (say) a GUI layout language. Tasks where you'd otherwise have to design, implement and teach extra languages (hand-written XML anyone?). With Lua you have to put in the effort only once. - Lua is simple, but not simplistic: Lua has a simple, yet powerful syntax which fits on a single page. The semantics are consistent and intuitive. Beginners can start to program right away. Teaching Lua is easy, excellent programming books are available. No huge and expensive IDEs and SDKs are needed, any text editor will do. Lua also has advanced features like closures, coroutines, meta-mechanism and lots of finely tuned details. All of these make it attractive for professional developers, too. But none of these features get in the way of beginners. The WoW Lua add-ons are a good example of the power of an open and collaborative environment. It nicely shows what a huge driving factor user contributed (active) content can be for the success of a project. If you want to quickly gain a huge library of gadgets and add-ons for your cell phone, then Lua is the way to go. You just have to make it easy for them ... Ok, this list is by no means exhaustive. But it's a start. --Mike