Extensible Embeddable Language

The Extensible Embeddable Language (EEL) is a scripting and programming language in development by David Olofson. EEL is intended for scripting in realtime systems with cycle rates in the kHz range, such as musical synthesizers and industrial control systems, but also aspires to be usable as a platform independent general purpose programming language.

EEL

Paradigm	Multi-paradigm: scripting, imperative, functional, object-oriented
Designed by	David Olofson
First appeared	2005 (2005)
Stable release	0.3.6 / February 4, 2014 (2014-02-04)
Typing discipline	Dynamic
OS	Cross-platform
License	GNU Lesser General Public License
Filename extensions	eel
Website	eel.olofson.net
Influenced by
Lua, C, Pascal

Philosophy

As to the language design, the general idea is to strike a practical balance between power, ease of use and safety. The intention is to help avoiding many typical programming mistakes without resorting to overly wordy syntax or restricted functionality.

History

The first incarnation of EEL was in the form of a simple parser for structured audio definitions, used in the sound engine of the Free and Open Source game Kobo Deluxe, an SDL port of the X11 game XKobo. This was a simple interpreter with very limited flow control, and a syntax that's quite different from that of current versions. This initial branch of EEL was first released in 2002, and is still used in Kobo Deluxe as of version 0.5.1.

In December 2003, EEL was split off into a stand-alone project and subject to a major rewrite, in order to be used for real time scripting in an embedded rheology application. This is where the switch from interpreter to compiler/VM was made, and the actual programming language EEL materialized. The first official release was in January 2005. Since then, EEL has evolved slowly, driven mostly by the personal and professional needs of its author.

Features

General

The language is not strictly designed for any particular programming paradigm, but supports object oriented programming, or more specifically, prototype-based programming, through a minimal set of syntax sugar features. Other styles and paradigms of programming, such as functional, modular and metaprogramming are also supported.

As a result of avoiding pointers and providing fully managed structured data types, EEL is "safe" in the sense that EEL programs should not be able to crash the virtual machine or the host application.

Highlights

• C-like syntax.
• Opaque references (as opposed to raw pointers).
• Dynamic typing.
• Automatic memory management.
• Exception handling.
• Built-in structured data types, such as:
  • string - immutable string.
  • dstring - dynamic string.
  • vector - fixed type numeric array.
  • array - array of dynamically typed elements.
  • table - associative array.

Example code

The classic hello world program can be written as follows:

export function main<args>
{
    print("Hello, world!\n");
    return 0;
}

The following is an example of a recursive function:

export function main<args>
{
    print("Recursion test 1:\n");
    
    procedure recurse(arg)
    {
        print("arg = ", arg, "\n");
        if arg
            recurse(arg - 1);
    }
    
    recurse(10);
    
    print("Recursion test 2; Mutual Recursion:\n");
    
    procedure mrecurse2(arg);
    
    procedure mrecurse1(arg)
    {
        print("arg = ", arg, "\n");
        if arg
            mrecurse2(arg);
    }
    
    procedure mrecurse2(arg)
    {
        mrecurse1(arg - 1);
    };
    
    mrecurse1(10);
    
    print("Recursion test 2; Mutual Recursion with Function Reference:\n");
    
    procedure mrrecurse1(arg, fn)
    {
        print("arg = ", arg, "\n");
        if arg
            fn(arg, fn);
    }
    
    local mrr2 = procedure (arg, fn)
    {
        mrrecurse1(arg - 1, fn);
    };
    
    mrrecurse1(10, mrr2);
    
    print(Recursion tests done.\n);
    return 0;
}

Internals

EEL source code is compiled into bytecode for a custom VM, which has a relatively high level instruction set designed to minimize instruction count and thus overhead. The EEL VM is register based and "stackless", as in not relying on the C call stack for managing VM contexts.

The basic memory management method is reference counting, which allows automatic memory management with deterministic timing, without the need for concurrent garbage collection.

The VM uses "limbo lists" to keep track of intermediate objects created inside expressions and the like, which greatly simplifies exception handling, and eliminates the need for active reference counting in every single operation.

Applications

Kobo Deluxe

Kobo Deluxe is an application of EEL.

External links

• EEL homesite
• Kobo Deluxe homesite