The Definitive Programming Language, Not

By: on June 13, 2006

[Peter Van Roy]( recently claimed
[slides]( that
there are signs of a *Definitive Programming Language* emerging that gives

> good solutions at its level of abstraction, allowing computer
> science researchers to move on and work at higher levels.

The argument is based on the observation that *four* languages,
designed *independently* and for *different purposes* all arrived at
the *same* layered language design of

1. strictly functional language at the core
2. deterministic concurrency (aka dataflow concurrency)
3. asynchronous message passing
4. global mutable state

The claim is that the odds of this happening at random are the same as
lightning striking in the same place four times and that instead we
should consider this particular language structure as a definitive
design that arises naturally and inevitably.

Unfortunately these claims do not stand up to scrutiny.

There are not four languages. The languages examined are Erlang, E,
Oz and, er, Oz. In other words Oz is in there twice, once as a
language for network-transparent distributed programming, and once as
a teaching language.

There are not four different purposes. The stated purposes of the
languages are Fault Tolerant Programming (Erlang), Secure Distributed Programming (E), Network-Transparent Distributed Programming (Oz), Teaching Programming Languages as Unified Discipline (Oz).
It is well-known that the only way to get fault-tolerance is through
redundancy, and that the only way to get redundancy is to have
multiple machines. This implies distributed programming. Many of the
language design choices in Erlang are due to it needing to deal with
this, not with fault-tolerance per-se. Similarly, E from the very
beginning aimed to be a language for *distributed* secure programming,
and many of its design choices are motivated by needing to deal with
distribution, not security per-se. Thus both Erlang and E derive many
of their design decisions from the feature that has been the main
driver for Oz – distributed programming.

The languages were not designed independently. It may be true that the language designs were carried out independently from *each
other*. However, there was a large body of previous research in the
area of distributed programming, which heavily influenced the design
of all the languages.

The languages do not have the same four layers. Erlang and E are missing layer 2 and 4
respectively, and E has a completely different layer 1 than claimed –
its core language is imperative, not functional, and E’s functions are
in fact just sugar for objects. The only layer that is common to all three is message passing. Given
that we have identified distributed programming as *the* guiding
design objective of all languages that is hardly surprising since
message passing is *the* fundamental mechanism by which distributed
systems communicate.

So we really have *three languages*, designed with the help of a large
*common body of research*, for the same *single purpose*, arriving at
the same *single layer* of abstraction for that purpose. There is no
statistical significance in that.

Even if the statistics were right, the idea of judging the fitness of
programming language design on the basis of such statistics is
fundamentally flawed. The known design space isn’t all that large so
the chances of several languages independently making similar design
choices is quite high. Language design follows trends. It is not at all uncommon to see several languages make similar design decisions which ultimately turn out to be wrong. For example there are a whole bunch of
languages with an imperative core, threads & locks, rpc, centralised
or replicated transactional store. That doesn’t make it any more
likely that this particular design is correct.

Despite all that the conclusions of the paper still have some
merit. The proposed four layers are indeed a pretty good design for a
distributed programming language. However they are by no means the
*only* sensible design. For example, actors and process algebras have
concurrency and distribution at their heart and arguably span all of
the proposed four layers with a minimum set of non-layered language
constructs. I am also becoming increasingly convinced that
transactions will turn out to be an essential, fundamental
feature. Overall there is still a lot of research to be done and we
are nowhere near a definitive language yet.



  1. This paper was invited as a talk at FLOPS (I was responsible for this, as pc chair). Rather than focussing just on his own work, on Oz, Peter van Roy chose to also publicize the work on Erlang and E. Researchers spend too little of our time extolling the virtues of others work, so I was delighted to see this.

    I agree with yoiu about the shortcomings of the analysis, but I also agree with you that the paper has a lot of merit.

  2. Robert says:

    There are all-purpose programming languages and there are specialized programming languages. Aside from SQL, specialized programming languages do not get enough respect from mainstream techies, as I’ll argue in an upcoming blog entry.

    Take statistical programming languages: the three most well-known are S, SAS, and SPSS. They are all at least 30 years old. We have not seen a ground-breaking statistical programming language break out into the mainstream for more than three decades.

    There is a new alternative, VILNO, available as an attachment to the August 31 blog entry at


  3. Peter Van Roy says:

    Unfortunately, the critique is flawed. Its conclusion is preordained and the evidence is carefully selected and trimmed to support its conclusion.

    For example:

    the main driver for Oz – distributed programming: this is false. Oz was essentially complete when the work on distribution started in 1995.

    Language design follows trends.: Joe Armstrong (Erlang designer), Mark Miller (E designer), Gert Smolka and his colleagues (Oz designer) are independent thinkers that are not so much influenced by trends. They all worked against the trend of their surroundings, in independent fashion.

    This implies distributed programming. Reducing everything to the needs of distributed programming is just not what happened. For example, Erlang was originally not designed as a distributed language, but as a language that allows programs to survive software faults.

    There are not four languages. The paper clearly explains that there are three languages and in how far that this can affect the conclusion. This is not an original observation in the critique.

    Unfortunately these claims do not stand up to scrutiny. The scrutiny is itself fundamentally flawed.

Leave a Reply

Your email address will not be published.

You may use these HTML tags and attributes: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <s> <strike> <strong>