Pliant is a superset of C. It means that you can pick any program written in C and translate it line by line to Pliant, even if the syntax is very different. On the other hand, Pliant is not a superset of C++ because it's object model is different (instance based instead of class based). Pliant provides the raw efficiency of C, but enables a lot more expressivity and flexibility than even C++ thanks to meta programming, reflexivity, and dynamic compiler feature.

Different authors will provide different definitions of it. In Pliant, meta programming is the ability to generate some code through a program. In very simple words, a code generator. The key feature of Pliant meta programming is that it is not purely syntactical code generation: the meta can test the type of each sub expression.

Historically, there are two kind of language implementations: Interpreters are executing from the source code through parsing then executing each instruction one after the other. The advantage is (simpler implementation plus) the availability of an 'eval' instruction which turns a string to a program which is a very usefull feature for some applications. The drawback is slow execution speed because much more time is spent in parsing than in executing if the program is executing low level algorithms as opposed to just being the high level part of an application where most time is spent in C written underlying libraries.

On the other hand, a compiler translates the program to native processor instructions at development time, so that no source code is necessary at execution time. The advantage is speed, and the drawback is lack of 'eval' feature, plus the difficulty to apply small changes when the application is provided as a free software, because recompiling always prooved to be less staight forward than expected.

A dynamic complier compiles each module of the program at startup time. So it executes from the source code and can provide an 'eval' instruction like an interpreter, but also run programs at raw speed like a compiler. Moreover, it can scan it's environment to optimise compiling for accordingly. The drawback is slow application startup because some time is needed to compile, plus more memory consumed because the compiler and it's datas are needed at execution time.

Please notice that both an interpreter and a dynamic compiler require the application to be provided as source code, so are not suited for some closed application where releasing the source code is excluded.

Lastly, some languages such as Java are using a compiler, but the target is not native processor instructions but a virtual machine. They provide neither the speed of native compilers, nor the flexibility of an interpreter, but provide great portability like interpreters and the ability not to release source code like compilers, plus decent execution speed for high level applications.

The ability for programs (mainly libraries) to extend the core features of the language through providing extra optimisation rules and so on.