Why do we need an embeddable programming language like Lua?

Question

What are the typical use cases of using an embeddable programming language? Do I understand it correctly that such language should be embedded into some program environment and should be able to be executed from there?

Peale

Embedded languages are typically use for end-user customization. They are usually very high level (i.e. dynamically typed, garbage collected, etc.) and easier to use than the language the application is written in. Sometimes this is done even if the language is never meant to be exposed to end users, so that internal staff (often less technical, like designers) can implement part of the app in a higher level language at a higher level of abstraction, or so that components that are likely to change often can be changed without recompiling the application. – Pufahl

@Pufahl thanks for pointing out the garbage collection thing! I forgot that very important point in my answer. I'll edit it to integrate that aspect. – Histaminase

You are more familiar with this than you think. Every day, billions of people use an embeddable programming language: JavaScript. It's embedded in their web browsers. It executes in the environment of a web page and is given access to the HTML Document Object Model of the page, and somewhat to the windows and such of the browser. Lua is also used to write filters in Wireshark. – Zucker

Answer 1

Since you tagged the question as "Lua", I'll give you an answer in the context of this language.

Introduction

Lua is written in C (almost completely compatible with C89 standard; the incompatible features can be easily disabled, if needed, using compile-time switches) and has been designed to be easily integrated with C code. In the the context of Lua, "integrated" means two different, but related, things:

1. You can easily write C code that can be used as a library by Lua code. The integration is achieved either by static or dynamic linking your C code to Lua engine's code. The linked library can then be referred to in your Lua code using the Lua require function.

2. Lua engine can be easily embedded in a C application, i.e. linked (again either statically or dynamically) to the C application code. Then the C application can interact with the Lua code using Lua's C application programming interface (Lua C-API).

Note: this can be done, with a little more effort, also with a C++ application.

Advantages of embedding a Lua engine

If your C application embeds Lua many, if not most, operations can be delegated to the Lua engine, i.e. either to code written using the C-API functions or, better yet, Lua code. Lua code could be embedded as C strings inside your C code or be stored as external Lua scripts.

Having part of your code logic implemented using Lua code has several advantages:

• Lua is simpler (less tricky) to learn and use than C, and it is much more high-level. It supports powerful abstractions, such as function closures and object orientation (in a peculiar way, using Lua tables and metamethods).

• Lua is a dynamic language: it requires no "off-line" compilation. You can modify the text of your Lua script and that's all you need to modify your application behavior (no additional compilation+linking steps needed). This simplifies application development and debugging.

• Lua is a safer language than C: it is really difficult to write Lua code that exhibits undefined behavior, as intended in the context of C/C++. If a Lua script fails, it fails "loudly". Moreover Lua supports an exception mechanism (although with a different syntax than C++) which can be employed to implement error management in a much easier way compared to C.

• Lua, as most dynamic languages, is garbage collected. This means that the programmer is spared the pain of manually managing dynamic memory, which is a major cause of bugs, leaks, instability and security loopholes in languages that lack garbage collection.

• Lua can "eat its own dog food", i.e. you can build a string at runtime (even in Lua itself) and if it is valid Lua code, your program can execute it on the fly. This is something not frequently seen even in other dynamic languages (still it is not LISP, but it gets closer, and with much more readable syntax). This enables Lua scripts to:

  • employ powerful text-based metaprogramming techniques, where Lua code can generate other Lua code and execute it on the fly;

  • implement domain specific languages (DSLs) in an easy way; Lua code can load at runtime other Lua code that is crafted so as to reflect the specific problem domain in which it is used (Lua syntax is simple, yet flexible enough to allow such things);

  • be used as a configuration language with ease: your application (written in a mix of C and Lua) can use some lua files as configuration files without the need to craft an ad-hoc parser for a specific configuration file format. Therefore you don't need to parse *.properties, *.csv, *.ini, or whichever other format you would choose if you hadn't the option of using Lua files for that purpose.

• Lua engine has a very small memory footprint (some hundreds kBs), packing powerful capabilities. With very few C code lines and a bunch of Lua files you could create a complete application that would require thousands of C code lines otherwise. The standard Lua standalone interpreter can be seen as just an example of embedding Lua in a C application!

• Lua has a very liberal open-source license, which enables its use even in commercial applications without much hassle. This also allows the modification of its source code to adapt it to special needs.

• Small memory footprint and easily tweakable C sources make Lua a perfect candidate for porting it on embedded systems or small microcomputer systems (microcontrollers, etc.). Many parts of the standard Lua distributions can be stripped off, reducing the core Lua engine in the ~100kB range. As an example, take the eLua project(now, 2023, apparently inactive), a modified distribution of Lua designed for embedded devices.

Histaminase

answer bookmarked for later re-read -- Applaud for the effort! :) – Swelling

Answer 2

Lua, and other scripting languages, provide various benefits that are dependant on your needs.

• Provide rapid iteration of development.
• Allow run-time code changes, such as reloading your UI in World of Warcraft which re-loads all scripts without stopping the game engine itself or logging you out.
• Provide a distinct API for your application for users to extend, without exposing critical parts of your system to the public. Such as text editors providing a macro language to allow you to integrate custom behaviour without giving you unfettered access to the internals of the editor itself.

The uses are really quite extensive and depends on the developer.

Sort