The aime programming language is geared towards two uses: application extension programming and site or immediate programming.
Application extension programming languages are languages for which there exists interpreters that may be embedded in applications that require a large degree of configurability or extensibility.
There is available a wide range of embeddable interpreters for many programming languages. The interpreters vary greatly with respect to such concerns as application integrity and security and integration between application and interpreted programs. The programming languages vary greatly with respect to just about every concern, ranging from syntax to scope and programming language paradigms.
And since the range of available choices is already great, one wonders where was the need for a new application extension programming language.
The need was in the surprizingly poor range of choices. While many available, very few solutions cover to a satisfactory degree the concerns pertaining application extension programming, with most significant concerns including:
Most embeddable languages (and their respective interpreters) are too absorbed with allowing and too little with data and application security. Such languages (their interpreters actually) offer to read/write files, allocate memory, even run other programs. And very few stop short of actually dynamically loading machine native code. Without providing any mean of restricting or controlling what such offerings are available for the interpreted programs.
The aime interpreter allows fine control over what features are available to the interpreted programs, over what functions, libraries, even data types. In the most restricted execution environment programs are bearly able to add numbers. In fact, the application explicitely defines what is allowed, instead of listing what is restricted. Applications may equally control how much memory is allotted to the interpreted programs and for how long are they executed.
Unless for bugs in the interpreter, the companion aime libraries or the embedding application itself, there is nothing an executed program can do to compromise the application or its data integrity.
Even those programming languages claimed to be geared towards embeddability integrate the application clumsily. Data or control transfer between the embedding application and the interpreted programs is ineffective and inexpressive.
The aime interpreter provides for such application state export mechanisms as application defined variables and constants, functions and data types. The latter may define data initializing and finalizing methods. The application defined functions may have data associated.
Program execution may be suspended and later resumed. Programs may be executed step by step. Control may be transferred to the application for the execution of selected functions.
For all their utility, application extension programming languages ought to be simple and evolving around familiar concepts. After all, it is the applications that are making use of them that are complex, not the interpreted programs. And yet, many embeddable languages take programming to ever newer paradigms.
The aime language is as simple as it gets, procedural imperative, featuring only the basic control statements.
Memory and resource management is automatic. As a high level programming language, aime has no proper memory concept and generally does not map low level machine features.
aime has a C like syntax, making it easy to learn and understand for all users familiar with C or a programming language that draws from C.
aime is plain and simple. Artificial is declined, no strange paradigms or special languare constructs intervene in between expressing solutions.
aime admits errors are not a programmable resource. For simple programming tasks allowing errors is at best a hindrance, hence aime programs executes in a largely error free paradigm.
The libraries available for the aime language define no operation failure, checking thus for errors is meaningless (when the commanded operations fail, like the division by zero fails, the program execution is terminated).
Unlike many programming languages, aime does not admit a special null, not existent or not available value or data type.
As for site and immediate programming, there are many times when a program is required for a specific site or in a specific context. Such program does not need to be concerned with making happy many users, it may not be needed over a long time and many uses (it may only need to run once), it may be of little ultimate value. For the limited program use, the programming should require little effort, for otherwise it is not worth it.
For site or immediate uses, aime may be not the best choice and surely, it is not the only one. Still, the language plainness and features such as automatic error dispatching and unconspicuous resource management do make aime an option for many small programming tasks.