What is Pliant ?


At the beginning, Pliant is a computing language.
It's target is: enable to keep better control on the computing system and better adaptation capabilities thanks to reduced complexity. This has been achieved mostly through enabling to develop everything in a single language that combines high expression power with execution efficiency.

Over the years, Pliant evolved to a full development and computing system named FullPliant.

It provides:

a complete development environment including the dynamic compiler, debugging an profiling features.

a database engine with very safe on disk format and easy to use infinite logging. It enables you to answer the following questions and requests, so important in an open computing system: 'Who is the (stupid) guy that has set the wrong value in this field that led to the company to produce a non conforming product in the end' or 'revert only what user Joe did from time A to time B because his account had been cracked'. The database engine also enables easy application coupling: replicate on the fly, with filtering and translating in the middle, modifications entered in computing application A, to application B using a completely different computing system. Lastly, the database engine enables to store not only traditional accounting databases, but also server side desktop documents (not storing the all document as a blob, but real server side editing, with proper crash recovery, rights check, history logging and so on).

a large usage scope cross-platform user interface graphical toolkit. By large usage scope, I mean that the API is suited for both light server side applications just like the web (where the server does IO only, and the client does all computations including positioning and autonomous handling of high level widgets), and very precise PDF like rendering including advanced color models enabling same on screen and on paper result. Moreover, a web standards (HTTP/HTML/Javascript) translation engine is provided. In very few words, you don't have to chose anymore between a traditional graphical interface (Windows, X11, Qt) or a web interface for your new application; you get both at once.

client and server side light so easy to customize implementations of several standard services such as DNS, SMTP (mail), LPR (printing), HTTP, VNC.

some basic administration utilities such as file browser, text editor.

it (will since the current versions are very primitive) contain basic desktop applications such as word processor, spreadsheet, drawing tool, photo editing tool, audio player.

So, what you can nicely do with FullPliant includes:

develop a web site with database interface, web 2 capabilities, using a high level language that completely hides the web 2 trickiness.

then use the native UI client to get more productivity for your staff (fast display, keyboard shortcuts) without changing the initial application code.

then use a VNC client to bring access to security sensible or underpowered client computers, once again without changing the initial application code.

add some computation intensive algorithms to your application (the language is efficient).

run your mail server, provide web mail, run your own DNS with easy customization if needed.

include entry level client-server desktop features (word processing, graphics), so extend possible applications beyond database without loosing server side consistency and reliability. An example could be centralized corporate documentation fully integrated with the traditional accounting system.

add trick-less automation in the middle since all applications are tightly integrated and use the very powerful Pliant language for scripting.

script your old applications with no usable open interface from the new one using Pliant VNC scripting tool (VNC scripting simulates user actions at keyboard and mouse level).


Let's close the loop with a bit of pure marketing wording: as I've stated in the first paragraph, Pliant is the only serious candidate to write everything using a single language, and it provides a well integrated simple implementation of most nowadays standard services, so it's the single candidate to run all your computing services in a single consistent human size environment in the end, with reduced maintaining and adaptation to your specific needs costs. Moreover, it will enable optimal transition path through providing simple scripting of many Internet protocols such as SMTP or HTTP, and even VNC scripting for mixing with totally closed existing applications.

In order to get more details about FullPliant design choices and innovations, you could continue through reading the introduction articles about various key pieces:

Pliant language overview

An Introduction to Pliant UI (graphic mode user interface)

An introduction to Pliant storage

FullPliant overall system FAQ

Where does FullPliant brings significant innovation ?

Reduced complexity thank's to focus on strong concepts on initial design rather than rich features set.
At very high overview level, let's say that Pliant brings conceptual or design innovations in four areas:

the language (well defined encodings of the program that enable nice features to be provided as libraries)

the user interface (proper bitmap, vector, positioning layering)

storage (PML encoding, global cache, incremental client server model instead of load save, live replication)

operating system (easy to maintain because minimal)

The current release is mostly the final one at design level, and is the result of several try and failures (restart from scratch) in most areas, so a painful to follow strategy on the personal side, and a slow to market losing strategy on the social side.

Why did you re-implement all standard tools, services and standard applications from scratch instead of interfacing already existing and more mature ones ?

The easiest is to use a metaphor: if you design a new car with a significantly more powerful engine. What will append ? All other parts, I mean the gearbox, the chassis, etc, will break.

In Pliant, reusing mainstream applications brought a consistency issue (they all have their own way of doing things so that the overall thing would look like a patchwork, a good example being configuration files), then interfaces are weak points (complex objects cannot be shared among heterogeneous applications), and finally current mainstream applications are crazily big so that digging in when something goes wrong is very expensive if even possible.
See 'Optimizing the service versus cost ratio in your computing system' article for extra details on the subject.

What can I run FullPliant on ?

FullPliant can run either:

as an application under your favorite Linux distribution

as an application under Windows operating system

as a standalone operating system named FullPliant, straight on top of Linux kernel.

Pliant language FAQ

How does Pliant compares to other languages ?

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 expressiveness and flexibility than even C++ thanks to meta programming, reflexivity, and dynamic compiler feature.

What is meta programming ?

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. One 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. The other key feature is that meta programming in Pliant is also the way to provide high expression power without sacrificing execution efficiency because the application can extend the compiler core capabilities.

What does dynamic compiler means ?

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 useful 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 proved to be less straight 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 optimize compiling accordingly. The drawback is slow application startup because some time is needed to compile, plus more memory consumed because the compiler and it's data 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.

What is reflexivity ?

The ability for programs (mainly libraries) to extend the language built in features set through extending the syntax and the semantic, and providing related extra code optimization rules. I mean, on mainstream languages such as C++, Java, Python, or Prolog, the set of advanced features is a fixed one directly built in the language. On the other hand, in Pliant, the language framework is very general and minimal so that advanced features can be implemented (added) at application level.