A brief history of Caml (as I remember it)

Caml is originally an acronym for Categorical Abstract
Machine Language . It was a pun on CAM (the categorical abstract
machine) and ML, the family of languages to which it belongs. The name
Caml has been maintained through the evolution of the language though
the present implementation has no relation with the CAM.

Caml has been designed and implemented in the
Formel project at
INRIA
headed by
Gérard Huet
until 1994 and its development now continues in project
Cristal.

The Formel project became interrested in the ML language in 1980-81.
ML was the meta-language of the Edinburgh version of the LCF
proof assistant, designed by
Robin Milner. It
was implemented by a kind of interpretor written in Lisp by Mike
Gordon, Robin Milner and Christopher Wadsworth. LCF itself was
written partly in ML and partly in Lisp. In order to be able to use
the LCF proof assistant on the various systems the Formel project was
using at that time (Multics, Berkeley Unix on Vax, Symbolics) ,
Gérard Huet decided to make the ML implementation compatible
with various Lisp compilers (MacLisp, FranzLisp, LeLisp,ZetaLisp). As
a member of Formel project at that time, I participated to this work
which also involved
Larry Paulson,
working at Cambridge University. The performances of
the ML implementation were improved by the addition of a
compiler. Also, I added types with constructors and pattern-matching,
following ideas from Robin Milner, borrowed from Hope, a language
designed by Rod Burstall and David McQueen. At some point, this
implementation was called Le_ML, a name which did not survive. It was
used by Larry Paulson to develop Cambridge LCF and by
Mike Gordon
for the first version of
HOL
as mentioned in
The Metalanguage ML (HOL documentation).

Around 1984, three facts motivated us to get even more involved in the ML
developments:

Luca Cardelli
had developed at Edinburgh a much faster implementation
of ML using his Functional Abstract Machine (FAM).
He also designed his own version of the language which was known at
that time as Cardelli's ML.

Robin Milner
thought it was a good moment to propose a new definition of
ML in ordre to avoid divergence between various implementations. He
defined the core Standard ML language which was later completed by a
module system designed by Dave McQueen.

Pierre-Louis Curien had developed at the same time a calculus of
categorical combinators and a correspondance between lambda-calculus
and categorical combinators which, as I noticed, could be seen as a
compiling technique for ML. Indeed, it was quite close to the original
implementation technique of Edinburgh ML but could be described, proved
correct and optimized in a simple way. This led to the definition of the
Categorical Abstract machine (CAM).

This urged me to develop a new implementation of ML based on the CAM.
However, the language we implemented then was not SML but ... Caml.
Why? Our main reason for developing Caml was to use it for sofware
developments in the Formel project and indeed, it was used for the development
of the Coq system which became, after Thierry Coquand's thesis in 1985,
the main aim of the project. We were reluctant to adopt a standard that could
later prevent us to adapt the language to our programming needs.
In particular, the Formel project developed syntax manipulation tools
(Philippe LeChenadec,
Michel Mauny)
which appeared useful for our developments and that we incorporated into
Caml. Having to synchronize with the SML team before adopting the language
modifications that seemed useful for our developments would have introduced
too much delay in our work and was anyway in conflict with the notion of a
"standard" language which was not supposed to evolve too much.
However, we tried to incorporate in Caml most of the improvements
brought by SML over Edinburgh ML.

The first implementation of Caml which appeared in 1987 and was further
developed until 1992 was mainly realized by
Ascander Suarez
who was my PhD student at the university of Paris 7.
When Ascander moved to Digital Paris Research Lab in 1988,
Pierre Weis
and
Michel Mauny, also
PhD students of mine, carried on with the development and maintenance
of the system. This implementation compiled Caml to LLM3 which was
the virtual machine for the Le_Lisp language.

I must admit that when the Caml development started, my experience
with language implementation was very limited. Relying on the LLM3
abstract machine and on the Le_Lisp memory allocation and garbage
collection saved a lot of work but could not lead to high
efficiency. The CAM model led to fast closure construction and good
environment sharing but was poor for value accesses in environments
and made optimizations difficult. It also potentially introduced
memory leaks since useless values were kept in closures. Also, I had
not realized that it was more important to have good performances on
non functional programs than on very functional ones. Above all, I
had overlooked the importance of portability and openness. In spite
of these inadequacies, for which I am initially responsible, Ascander,
Pierre and Michel did quite a nice work.

In the year 1990-91,
Xavier Leroy
designed a completely new implementation of Caml
based on a bytecode interpretor written in C and
Damien Doligez
provided it with a very good memory allocation capability. This new
implementation, known as Caml Light, was highly portable and run
easily on small machines such as Macintoshes and PCs. It replaced the
old Caml implementation and highly promoted the use of Caml in
Education and in research teams. The stream type and the parsing
facilities it offers, due to Michel Mauny, is issued from a continued
effort of the Formel project to promote syntax manipulation tools.
Finally, in 1996, Xavier Leroy made Objective Caml available which
improves over Caml Light by its high level module facility, its
object-oriented features and its native code compilers which make caml
more competitive with imperative languages such as C in terms of
performances.
Didier Rémy
should be mentioned for his influence on the objective-oriented
aspects implemented by Jér&ocirc,me Vouillon and also at other
moments of Caml evolution.

Besides these mainstream Caml developments, one should also mention
other compilers such as BIGLOO developed by
Manuel Serrano
and Pierre Weis, Camlot by
Régis Cridlig, CeML by
Emmanuel Chailloux.
An implementation for parallel machine was made by Francis Dupont
and an implementation of a lazy functional language Gaml was made by
Luc Maranget,
both from project
Para at INRIA.
The Chamau implementation by Michel Mauny and
Daniel de Rauglaudre
offers unique syntax manipulation facilities.

I don't know if there is any lesson to learn from this fifteen
years effort. Certainly, seen from 1996, the story could have been
more linear. However, through essays and errors, a capacity for
producing high performance portable and flexible functional language
implementations has emerged in France. Caml is used in education, in
research and new applications emerge such as the Web browser MMM
written by
François Rouaix.
Many people have contributed their best to that story and credits
should be given to all of them...