Pliant un-success story

The path to deciding to create a new language

My name is Hubert Tonneau. I've been born in 1968. Legendary will soon add that I had a computer in hand, but the problem is to get an agreement on what model. More seriously, I've discovered computing in 1981, and got so passionated with it since then that I've soon turned to a boring man, or maybe the other way round. I've owned an TI58C, then a ZX81 on which I learned assembly and patience (the tape backup system worked randomly), then a Dragon 32. At that time I was more interested in writing games than playing with.

The next step came in 1984 when my father decided to buy me an IBM-XT, so built a small company and asked me to develop a database for managing exchanges of to be rented video cassettes among shops. This was my first professional application and was written in IBM compiled Basic with Fabs (an assembly written buggy B-Tree implementation).
I soon got frustrated about how repetitive programming could be, so started writing a code generator and reading books about other languages: Pascal, C, Ada, Eiffel, Cobol, PL1, Lisp, Forth (later C++, Prolog, CAML).

Around 1988, I had already acquired a serious computing culture, and was firmly convinced that my main task would  be to write a new more powerful programming language.

Crossing the desert

Then came the longest and hardest part of it: getting from a general idea to finding the key concepts that really bring something: 10 years thinking about it many hours a day ... with no result.

A language is something fairly abstract so there is a lot of freedom so that you have nothing concrete you can rely on to guide you on how to start with, but in the end, it's just like a cake recipe: the value is in the harmony of various components, not the sum of each component.

The only important decision I took at that time was to go to industry rather than university, because I was convinced than only putting it at work on real applications is a way to get rid on some nice looking but still poor concepts in fact. I just kept contact with some researchers at CAMS to fast exchange ideas with clever people.

I've met several people with fuzzy ideas of new better ways of handling computing, but they tend to surrender after a few months or years.
Keys to the success have been for me:

I started early

I started on limited, so easier to master hardware

I have a strong constitution, and a lot of perseverance

I had psychological problems with my family, and it turned to be a strong booster

I organized my life a bit like a high end sport player so I could fully concentrate on the main issue

and the biggest one is: I have no leniency for myself.
When I end a software, I wait a few months, review it, and most of the time I conclude: it's no good, I will have to find better way to deal with the subject then restart from scratch. I ended with the right concepts in many areas largely because I did several generations in few time instead of ever and ever extending the first generation.

Starting early has several impacts:

I had already serious computing culture when I entered university in 1987, so that I was not too much influenced by teachers cleverly introducing existing solutions.

I could spend a lot of time on the subject before being limited by having a family and a home related constrains.

The disillusion

I was very proud when I published Pliant on the net in 1999, and firmly convinced that through providing it to the free software emerging movement, it would be a key part of free softwares success, and that I would be part of the movement I like the philosophy of, and would share the load with.

Well, it did not append the way I planned it: Pliant was, and is still just ignored.
There are several reasons for this. One is that nearly nobody nowadays would start an application directly on top on a language: people need a full environment with database engine, web server, etc. Another was lack of documentation. Yet another was not enough communication on my side, plus no attempt to main free softwares high mass meetings. On the dark side, I discovered that a free software success is largely based on hijacking closed software marketing force, so being really new instead of a free copy of something already well known is a serious handicap. Then come the politic reasons we will see at the end of this document.

On the other hand, some people liked very much playing with Pliant, so I have always been supported by a few people, the most significant ones being my colleagues Loic Dumas and Cyril Checroun. They did not contribute much to the technical side of the project, because concepts is a nearly impossible to share thing, but provided useful advises, patient feedback, and even more important, then greatly helped me resist the doubt of: I cannot be the only one to be right; if nobody is using the project, then it must be wrong.
Kudos also to Marcus Vinicius Santos that have been the first brave to provide a Pliant course in a university.

So, I started interfacing other free components in order to provide a ready to use development tool. The main problem I met is that mixing a strong design based system with a features rich rather than strong design one, moreover aligned on different conventions, brings down the benefit of the strong design in no time. So, year after year, one after the other, I reached the point where the written from scratch Pliant service got better than the well known interfaced one.
The last to surrender has been the user interface where, up to 2005, I have used HTTP/HTML/Javascript and finally switched to Pliant UI.

The last kilometers of the marathon

Around year 2005, I had understood that I would have to rewrite in Pliant most computing software key parts in order to get a significant enough consistency bonus so that switching to a different system worth the effort, and that I would have to do it alone because contributors proved to all go the shorter interface way. Once again, sharing strong concepts discovering effort is just not possible.

I also started to understand that I was in a hurry because I would soon hit the age limit. Some might be lucky people that sit behind their desk 8 hours in the morning and get job done step by step, day after day. I'm not, and for the very difficult parts, I have to concentrate up to my breaking point several days or even weeks long to get the really good idea suddenly pop up. This is exhausting. If I try to do it step by step, it never appends.

So, at some point, I just stopped advocating about Pliant, stopped documenting, mainly stopped packaging it, and concentrated only on getting as fast as possible to the point of having all key parts properly led down at concepts level. This is what I call reaching the final perimeter. This has been achieved in may 2008.

Earning my living

Even if I'm more an intellectual than a business man, Pliant has always been used in the industry since I've always developed applications for the industry at the same time as developing Pliant then Fullpliant.
It provided me several things at once, so has been a good deal:

immediately test concepts on the real, so get rid fast of the ones that look good on the paper but prove to be wrong on the field.

force to spend enough time tracking the bugs in order to keep the code reliability high.

it has taught me two hard parts about applications development which are maintaining code over the long run and transitioning a production site to a significantly different new application.

it was not database only applications since I did integrated tools for the printing industry, so we had to cope in a single system with not only classical computing easy databases issues, but also with more computing intensive issues related to high end graphics.

and last but not least, it provided me the freedom to take as many years as I needed to find the good concepts as opposed to building a tiny Pliant company that would have required immediate incomes so forced me to go the fast dirty way.

The future

I'm now what I call an old man since I've finished with the finding new concepts part of my life.
I started with the hope to provide only one serious concept improvement in my life: a language; I ended with providing four of them: the language, the storage system, the user interface stack, and the color management.
So, it has been harder and longer than expected, but what ever success (spreading) might come at some point or not, I'll still be proud to have turned to reality the potential capabilities nature gave me. No more, no less, since I've only chosen half of the way things evolved.

My main activity for the year to come (2008) is to catch up with documentation.
Then I will resume polishing the code within the already reached final perimeter, helping people that want to access the guts of Pliant to bring it further, and reviewing contributions.
I've been a researcher, I'm learning to write, and I will learn to communicate and coordinate.

The longer term future of Pliant mostly depends on how external contributors will organize to work together, and if Pliant suddenly gets fashion at some point because one start to cleverly market the design improvement it brings and others follow, or if the first one to bring it under the light will be an historian, so I have no idea what the long term future will be.

Pliant in the real world

You will find bellow the list of (not) all softwares I've written:


An database application for managing exchange of video cassettes between shops


Lisp interpreter with revised syntax


First generation database application for Heliosam (Heliosam was preparing helio cylinders for the printing industry), based on Borland Paradox


A text editor, first generation (like everybody else)


Second generation database application for Heliosam, based on a code generator database engine written in C language


Low level C++ libraries (provides glibc level services, a bit like Qt now does)


Parametrical curves (alternative to Bezier) that have been generalized to multi dimension in 200x years


PostScript RIP based on home made graphic stack, written in C++
Designed to RIP 1 square meter drawings at 2400 dpi with more than 4 components per pixel


Pliant interpreter as a scripting language on top of C++ libraries


Pliant compiler (runs on OS/2, then Linux and Windows, includes the code generator)


Pliant low level libraries (provides glibc level services)


Pliant database engine (simple and safe)


Pliant HTTP server (meta programming at work)


Pliant FTP server and client and client


Pliant SMTP and POP3 servers and clients


Pliant LPR server and client


Pliant DNS server and client


Pliant cryptography subsystem


Pliant profiler


Third generation database application for Heliogroup, based on Pliant database engine and Pliant HTTP server


Second generation graphic stack written in Pliant
Handles in memory high resolution compressed images, deals with more than 4 colors per pixel, provides many Epson printers, HP PCL5 et PCL6 drivers, PNG, TIFF, JPEG interfaces.
Handles vector drawing, fonts rendering engine and display lists support.
Contains a positioning toolkit.


Pliant high end color management system
No less than the only professional grade free one.




FullPliant installation and administration scripts, first generation


Openpack workflow software for the prepress


Pliant VNC client
With scripting capabilities.


Pliant UI client and server
Server has no less than three frontends: UI protocol, VNC protocol and HTTP proxy
Client has no less than three frontends: Linux framebuffer, X11, Windows


Pliant text editor (using Pliant UI user interface)


Pliant file manager (using Pliant UI user interface)


Fullpliant operating system installation and administration scripts, second generation


Pliant tiny client server word processor (using Pliant UI user interface)


Forth generation database application for Ozeanys, based on Pliant database over Pliant storage and Pliant UI server

So, unless somebody else stands up and shows code, I win by far the price for the largest amount of applications written by a single man.
One could (some do) say that this list is the result of my too big ego and the overall thing is useless because there are equivalents of most of the softwares I've written that are much better spread, packaged, and maintained, so I should rather have spent time contributing to these.
This is just a way to avoid the more interesting question: why is my list so much larger than any other man one ?
Because I've started the house by the foundations (see crossing the desert paragraph) whereas others want to start the windows and roof (what can be immediately seen) first. In other words, it is because I used Pliant language that I could get such a great speedup in the 2000-2007 years.

On concepts, the working force is completely unrelated to the number of men involved. At that point of history, with better concepts, it has been possible to shrink computers complexity down. I had the intuition of it, I tried it hard, I did it. There is less ego issue here than fight for the freedom to not being imposed an assumed to be poor, yet mainstream, solution.

Many people would like, or still believe that, when something better appends, it is welcomed. History study showed me that very often, the selected solution is just to put the innovation aside to protect the existing positions. Now, the art of it is to find some apparently good reasons to do so.
In the end, Pliant is not just a nice contribution to free softwares, but it also proves how the ratio of useful lines versus glue ones is low on all nowadays softwares. Since the problem is largely underestimated, Pliant is also a little bit a blow at the face of all a generation of programmers: you can't seriously expect them to welcome it.