Tau languages

For the moment I’m not going to justify this page, just observe that everyone thinks that there is something wrong with every existing programming language, that they can do better, and that this implies that there’s a single language that is somehow best for every task.

Some languages which between them triangulate the properties I’m looking for:

See more coherent discussion at:

Alistair musings

I cannot disagree with the above as far as it goes, but what do you propose to do about it? Here’s my plan: a hierarchy of co-existing machine abstractions. This is about making it easy to write new programming languages, and getting them to work together well. The idea is to make a taxonomy of programming language world-views and then formalise it in virtual machines. We can put all of the pure functional languages in one machine, which is itself implemented along with other garbage-collected languages on top of another, which is in turn implemented along with languages that favour explicit memory management on top of a virtual machine which provides low-level memory allocation, and so on down to the metal. Not only does this share work (e.g. on the garbage collector) it also means that similar languages do not need to go down to a low level in order to work together.

I’m slightly afraid that a tree of machines is insufficient. For example, the following appear to be orthogonal concepts every one of which deserves the virtual-machine treatment:

Many languages have subroutines and it makes sense to implement them all in the same way using the same calling convention.
Languages with exceptions ought to mesh well with each other. In particular, there ought to be no runtime overhead for catching an exception thrown in another language if nobody in between has installed an exception handler, and this should remain true even if the call stack includes many different languages.
Garbage collection
Languages with garbage collection ought to mesh well with each other. When a non-garbage object in one language has a reference to an object in another language, that should behave exactly as it does within a language.
Languages with threads should mesh well. For example, they should agree on the choice of mutex primitive.
Many languages can serialise objects, for example in order to store them on disk or send them over a network. This ought to cross language barriers seamlessly.
Optimisation and code generation
Programs written in multiple languages are traditionally much slower than they could be, due to the piles of glue code at the boundaries. Languages with similar world views should be able to e.g. inline each others’ subroutines.

That list could grow and grow but it’ll do for now. So how do we get this lot organised? If I’m designing a new language, how do I pick-and-mix the ingredients I need?

We also need to think about evolution of standards in this context.

Last updated 2005/12/26