Pliant is a very small, highly modular, dynamically compiled language with a trivial syntax, where advanced features can be written in the language itself, as modules. Modules can consist of normal library routines or meta-programming functions. Meta-programming allows allows you to manipulate the generated code for optimizations, language extensions/customizations, or higher level abstractions.
The meta-programming capabilities of Pliant eliminate the barrier between low level languages like C and high level languages like Lisp or Python. This is possible due to Pliant's 2 level design. First is the "Expression" level in which Pliant resembles LISP in several aspects and which contains a rather powerful "eval" semantic. Next is the "Instruction" level, which is very much like a subset of C. In Pliant, compiling is seen as nothing more than translating a program from the Expression to the Instruction level. This is done by a dynamic compiler plus optional "meta functions" which are provided by the program or by libraries. Due to the machine oriented structure of the Instruction level, Pliant programs are then theoretically as fast as ones written in C.
In addition to meta-programming, Pliant includes many modern programming principles, such as static typing, objects, lazy evaluation, reflective compiling, reference counting garbage collection, built in debugger, and a clean syntax. It scales well from low level systems programming to high level control languages, additionally it includes the capability to be its own configuration language. It comes with many pre-built components including HTTP, FTP, SMTP and POP3 servers, and a database engine.
One of the many things that attracted me to Pliant is the ease which you can create interfaces to external C libraries. It cannot really even be compared with a foreign languages interface, as its almost as integrated with C as C++/ObjC. There are a few catches, but its really the best I've seen in a non-C language.
Hubert responded to my summary... I'll rework it at some point to take his comments into account.
There are two key features about Pliant as a language:
- dynamic compiling
- the program can perform sophisticated computations at compile time
- the program can compile some more code at run time).
- dual program encoding
- high level expressions
- low level instructions
- clear extensible way to make the translation.
Any good description on Pliant language will focus on these two features since it's what's new in Pliant (also I understand that stating this is contradictory with my willing to have contributors step in and suggest new descriptions).
- dynamic compiling brings flexibility:
- no need for 'make' 'configure' and other hugly tools
- a kind of 'eval' function that gives you the flexibility of scripting languages (the macro language is the core language)
- dual program encoding is about efficiency: I state there cannot be an efficient high level language without it since it would required the compiler to have all optimizing rules for all possible computing fields hardcoded in it.
About FullPliant and others (HTTP, SMTP, ...), what I call the overall Pliant project, we should have a completely different description, and record both of them on each site, in order to avoid confusion, also I did start the confusion through not doing so.