Embedded Scripting Language

Under Mission Scripting Requirements, there are several requirments that have pushed us towards adopting an embedded scripting language including:

• Must be possible to develop new commands and behaviors without recompiling code.
• Mission language must be human readable
• Mission language must machine readable.
• Mission language must enable strong type checking
• Mission language must enable unit checking.

The requirement Limit the interconnectedness of code to minimize full-system recompiles. also pushes us towards the use of an embedded scripting lanuage.

But which language to use? We defined three measures:

• Popularity (it increases the odds that a user may know the language, and helps narrow the list of possible choices)
• Benchmark Speed (we are targeting a low-power processor, so wasting cycles is considered bad – also, we'd like performance to be within an order of magnitude of the performance of compiled c++).
• Embeddability (goal is to embed the scripting language into the command application)
• Size of the Embedded API (our target has a small memory size – smaller is better)

Popularity

What follows is a short list of the most popular embeddable scripting languages (rankings from list of all programming languages at http://www.tiobe.com/index.php/content/paperinfo/tpci/index.html:

• #5 PHP http://en.wikipedia.org/wiki/PHP
• #6 Python http://en.wikipedia.org/wiki/Python_(programming_language)
• #7 Perl http://en.wikipedia.org/wiki/Perl
• #10 Ruby http://en.wikipedia.org/wiki/Ruby_(programming_language)
• #11 JavaScript http://en.wikipedia.org/wiki/JavaScript
• #15 Lua http://en.wikipedia.org/wiki/Lua_programming_language
• #47 Tcl http://en.wikipedia.org/wiki/Tcl

Benchmark Speed

Benchmarks are, of course, a poor measure of the performance of a specific software or hardware platform for a given, unless the task, unless the task is very similar to the benchmark. However, they are probably the only measure we have available. The recent benchmark results here: http://shootout.alioth.debian.org/u32/benchmark.php?test=all&lang=all shows (from the above list) Lua finishing first, followed by Python, Perl, and PHP in a wide battery of test on a single processor Linux machine (JavaScrpit, Ruby, Tcl are not included in the benchmark). An older benchmark, here: http://shootout.alioth.debian.org/gp4/benchmark.php?test=all&lang=all has the same results for Lua, Python, Perl, and PHP, with Ruby, Tcl, and JavaScript following behind.

Embeddability

From the above list, the languages most amenable to being embedded in a larger application appear to be JavaScript, Lua, Python, and Tcl.

Size of the Embedded API

It is difficult to determine the size of the complied libraries for each of the above languages. However there are references to the compiled size of the Lua library being 230K, while the Jim interpreter for Tcl is only 70KB. Sizes of the Python and JavaScript libraries are not readily available, but are sometimes described as being "large".

The Winner: Lua

Based on the above criteria, Lua appears to be the winner – it is relatively fast (only 9.9x slower than c++), has clear and concise instructions and examples for embedding in a larger application, and our compiled Lua lbrary is only 311KB when compiled for our target platform (273KB when compiled for the host). This is larger than the smallest implementation of Tcl, but small enough for our needs.