In the predecessor project APPLEs, advanced procedural programming languages have been proposed as a new kind of imperative programming languages requiring significantly fewer language constructs and concepts than standard object-oriented languages while at the same time providing more expressiveness and flexibility. Furthermore, some core concepts of aspect-oriented languages are covered, too, without requiring additional language constructs for that purpose.
Even though the concepts developed there, including open types, global virtual functions, and modules as core concepts, are basically language-independent, they have been implemented as language extensions for C++ (yielding the language C+++), mainly for pragmatic reasons. On the one hand, building a new language upon an existing one has several advantages, both for its designer and its users, e. g., existing libraries can be reused, programmers do not have to learn a completely new language, and basic language features such as primitive types, operators, and control structures as well as more advanced concepts such as function and operator overloading, default arguments for parameters, templates, namespaces, etc. do not have to be reinvented. On the other hand, the new language inevitably “inherits” everything from the existing one, even if parts of that “legacy” (e. g., classes, virtual member functions, pointers, arrays, etc.) are deprecated in the new language because they are superseded by superior concepts.
Since C++ in particular is already a very comprehensive and partially extremely complex language, extending it with even further concepts may appear quite hazardous. Therefore, it seems reasonable to leave the path of extending C++ and to design a new pure advanced procedural programming language starting from scratch, that merely contains the language constructs and concepts deemed essential and is no longer burdened by any legacy of an existing language. Of course, this is also a unique opportunity to integrate more “exotic” concepts such as numbers with unlimited size or precision and a fully extensible syntax for expressions, statements, and declarations.
The envisaged language will be based on the three core concepts of advanced procedural programming languages, i. e., open types, global and local virtual functions, and modules. Other interesting features will include:
null values for all types;
direct language support for tuples and sequences;
numeric types with unlimited size/precision, which are efficiently implemented and integrated into the language;
user-defined operator symbols, control structures, and declarations, i. e., a fully extensible syntax;
virtual variables, whose read and write accesses can be transparently redefined;
types as first-class values.
At the end of 2008, a large part of the conceptual and design work has been completed and first steps towards implementing critical parts of the new language (in particular, the full syntactic extensibility) are being envisaged. Of course, major parts of the code developed during the APPLEs project, e. g., for implementing open types and global virtual functions, can be reused. On the other hand, implementing these concepts with a native compiler opens the door for numerous optimizations which have not been possible with the precompiler-based C+++ implementation, and it is, of course, an aim of this project to exploit this potential, too.
During 2009, the project has been renamed to STEEL (Statically Typed Extensible Expression Language) and later on to (Modular, Statically Typed, Flexibly Extensible Programming Language), since the syntactic extensibility of the language has become the predominant goal as well as the most ambitious challenge.