Lambda the Ultimate

I figured the window was narrow on this one. :-)

the April 1 jokes are probably just a reflection of the he Haskell community having a sense of playfulness and curiosity. The paper makes it clear that they didn't realize the full expressive power of several of their ideas (e.g. type classes and monads) until they were implemented and explored.

From my likes & dislikes, the discussion of type classes is very good and illustrates many of the innovations with respect to type systems. I liked the discussion on the early attempts to model IO using streams, continuations and worlds. But the section on monads could use a bit of work - but then those of us from the outside still have a hard time understanding monads. The paper comes close to being a real good description, but falls slightly short in connecting the dots.

From a limitations perspective, the two things that come across are the formal specifications and the module system. From my understanding, a formal spec was being attempted at one time but was abandoned at some point. The thing that I didn't get from the article was the reason the formal spec was unattainable (i.e. what in the syntax/semantics of Haskell made that goal unreachable - other than time).

It will be interesting to compare the Standard ML paper. SML is at the conservative end of the spectrum, whereas Haskell is much more playful - a difference that is noted a couple of places within the article.

Formal semantics was an original goal, but never actually attempted. One of the reasons the article mentions is that the user only needs to know the dynamic semantics, and not the statis semantics. (Is this really true?) And because the dynamic semantics of Haskell is not that complex, users had no problems reasoning about their programs without formal semantics.

The article also mentions that in hind sight not having formal semantics contributed to the rapid development of Haskell.

Formal semantics was an original goal, but never actually attempted.

This is not quite correct, there were at least two attempts: an early one by Peyton Jones and Wadler, trying to define Haskell's static semantics along the lines of The Definition of Standard ML (never got past draft status), and a later one by Faxen, mentioned in the paper, which covers Haskell 98.

I'm not aware of a dynamic semantics, even though they claim it'd be simple (which I'm not entirely convinced of).

This paper looks very interesting, particularly the section on the type system and the occasional comment on the different directions taken compared to ML.

I also see three of the originally proposed language names have since been adopted by different projects - Mozart (Oz), Nice and Curry.

Well, Oz meets the age criteria. And I imagine that the history of its development would be fairly interesting.

...here's some candidates that might qualify:

• Standard ML
• Caml/OCaml
• Modula-3
• Self
• Eiffel
• REXX
• Perl
• Java

You mentioned Modula-3 but not Oberon?

Oberon-2 is the final member in the family of Pascal languages, begun in 1985 by Niklaus Wirth and Jürg Gutknecht.

ETH Oberon home page

Books and papers are available online for download.

Earlier on LtU:

Project Oberon
Oberon Script

Pascal was in the previous go round, though papers on Modula, Modula-2, Oberon, Oberon-2 and Component Pascal could qualify.

Unfortunately, there is no Oz submission to HOPL III (as far as I know). Oz had a long birth process starting in the early 1990s from logic programming and maturing to a broader view. This gives it a different perspective on language concepts than Haskell. Two important precursors of Oz were AKL and LIFE. Many people were involved in the creation of Oz. Some of the main contributors are Sverker Janson (AKL), Seif Haridi (AKL), Hassan Aït-Kaci (LIFE), and Gert Smolka (Oz). Some of the history is explained in the paper Logic Programming in the Context of Multiparadigm Programming: The Oz Experience (TPLP Nov. 2003). See Section 8 for the history and Section 9 for some lessons learned. Oz development is ongoing. Recent work is on programs as collections of first-class components communicating asynchronously: see the paper Failure Handling in a Network-Transparent Distributed Programming Language (LNCS 4119, 2006). This work is influenced by Erlang. In the SELFMAN project we are just starting on a first-class component model for Oz, extending the kernel language with ideas from the Kell calculus developed by Jean-Bernard Stefani's group at INRIA.

My vision for the future of Oz is explained in the paper Convergence in Language Design: A Case of Lightning Striking Four Times in the Same Place (FLOPS 2006, LNCS 3945, April 2006).

In the programming language community, there are many projects with a vision. Haskell and Oz are just two of them. There are also E, Erlang, Mercury, Curry, Scheme, Scala, and many others. I think that this is a healthy state of affairs. Projects should be free to work out their visions independently and only occasionally look over their shoulders to see how the others are doing. Otherwise progress would be much slower. For example, look at the history of astronomy. Consider how Ptolemy slowed down the progress of astronomy for fifteen centuries by putting all his weight behind a geocentric theory in his Almagest, even though Aristarchos of Samos already had a quite well-developed heliocentric theory several centuries earlier.

Still leaves me wondering which languages are in play. ...and we can always second guess the inclusions/exclusions. :-)