Path: utzoo!attcan!utgpu!jarvis.csri.toronto.edu!clyde.concordia.ca!uunet!mcsun!ukc!dcl-cs!aber-cs!rupert!pcg
From: p...@rupert.cs.aber.ac.uk (Piercarlo Grandi)
Newsgroups: comp.lang.misc
Subject: Re: Late Bloomers Revisited
Message-ID: <PCG.89Dec17184350@rupert.cs.aber.ac.uk>
Date: 17 Dec 89 18:43:50 GMT
References: <1TmbNv#4mK14j=eric@snark.uu.net>
Sender: p...@aber-cs.UUCP
Followup-To: comp.lang.misc
Organization: Coleg Prifysgol Cymru
Lines: 171
In-reply-to: eric@snark.uu.net's message of 13 Dec 89 09:02:07 GMT


In article <1TmbNv#4mK14j=e...@snark.uu.net> e...@snark.uu.net
(Eric S. Raymond) writes:

   A couple of well-informed comp.arch regulars have suggested that I may
   have been a bit too peremptory in dismissing Algol68's influence on later
   language development.

   Would dmr or anyone else with certain knowledge care to comment?

In the beginning there was Algol 58, and this was the ancestor of
Jovial.  Algol 60 was then defined and quite different from Algol
58 (and we lost forever the very important distinction between
parallel and serial implementations of arrays of records, as it
appears in Jovial).

Just after Algol 60 was defined, people started working on its
successor, provisionally named Algol X, to be more oriented to
non numerical problems, and with a standard io suite and
representation. The three major problems with Algol 60 were that
it was heavvily oriented towards numerical computations, it
lacked any standard hardware representation, and had no standard
io library.

From Algol 60 people at Trondheim derived first Simula I, then Simula 67,
which were OO supersets of Algol 60. Apparently they were not seriosuly
considered as candidates for Algol X. History may have been weel different
otherwise.

In the States PL/1 was defined, with a completely different philosophy
(not an algorithmic language, but a programming language).

N. Wirth, while in the USA, worked on PL/360 and on Algol W,
which had a minor but interesting effect on subsequent history;
PL/360 was structured assembler, with an algol like syntax, and
the other was an extension of Algol 60 with records and strings
etc...

In the UK, the CPL language (by Cambridge and London
Universities) project was started, and it produced a nice
language with operators, valued blocks, and lots of other nifty
aspects. To implement it, M. Richards implemented a very small
subset of it, called BCPL, which was at the same semantic level
as say PL/360, but machine independent, higher level (another
such language, byt the way, was Neliac, by Halstead, which was
quite good, IMNHO), and with only one data type, the word, and
only one type constructor, the array, but had sophisticated
control structures and was simple and fast.

In Europe, two landmark events happened; Dahl, Dijkstra, Hoare
authored "Structured Programming", and Van Wijngaarden proposed a
new technology for grammars that could be used to describe
context sensitive aspects.

After Hoare's paper on data typing in "Structure programming"
Wirth designed a language, called Pascal, that implemented a
*very small* subset of Hoare's ideas, essentially those that
could be implemented with strightforward code generation; such
interesting ideas as arrays with other arrays or sets or records
as indices were lost, and so on.

After Van Wijngaarden, groups in the UK and Holland defined a language,
very influenced by CPL, that was described in the new Two Level Grammars
invented by Van Wijngaarden. The new language was a very ample extension of
Algol 60, and not synctactically compatible with it, and was designed to
cover almost any area of programming, with just a small set of basic concepts,
that could be combined in many ways.

A small war ensued between the Pascal, Wirth, Hoare, Dijkstra
camp, and the Van Wijngaarden, Algol 6[68], CPL, camp; Pascal
was hailed as a theoretically sound language, Algol 68 fans retorted it
was too simple and limited to be adopted as a general purpose international
standard.

The latter point of view prevailed, and Algol 68 was adopted as
an international standard.  In 1975 a fully revised language
report and a slightly revised Algol 68 language were published.
It proved exceptionally difficult to provide a compiler for full
Algol 68, because the language syntax was *very* context
sensitive, and some language rules were *very* subtle, but
eventually it did happen.

In the meantime, Pascal, which had been rejected because it was
considered too simplistic, achieved fame and popularity because a
simple, free implementation was provided.

In the meantime BCPL too, much for the same reasons, had become
popular, and, thanks to links between Cambridge UK and some USA
research centers (Xerox, MIT, Bell Labs), had been adopted in
several parts of that country. In particular BCPL was to be the
implementation language for the Multics Project, before they
decided to switch (with much much pain) to PL/1. Indeed the BCPL
compiler on Multics is older than any PL/1 compiler, even if most
Multics users don't know there is one.

It so happened that certain Bell Labs people were working on
Multics, and they were certainly exposed to BCPL, and when Bell
Labs got out of Multics, they decided to build a very small OS
somewhow inspired to Multics (by the way, it is one of the
tragedies of history that many current Unix workstations are far
more powerful than the old Multics machines, yet the Unix they
run is still far less sophisticated, simple and efficient than
Multics was).

It also happened that the GE 600 machines used for Multics were
also popular in a certain canadian university, that took the BCPL
compiler and hacked it a little to create B, a less odd looking
version of BCPL (which had quaint British syntax, and also used a
very small character set, because of the use of very old printers
where it had been developed). It also happened that Bell Labs
had as a major service machine a GE 600 machine, and B was
installed on it.

In the meantime the Unix kernel had been evolving, and the
authors felt it was no longer sustainable having it in assembler.
The took B as a model, and developed C, a very small (initially)
extension to it. They added (initially just a few) different
lengths of integers, and symbolic offsets into arrays, turning
them into structures.

About the same time, several people from cambridge UK happened to
visit Bell Labs, among them S. Bourne, one of the authors of the
Algol68C (a large subset of algol 68) compiler. This strongly
influenced the /bin/sh shell syntax (and its implementation), the
adb debugger, and the further evolution of C, which however still
retained its fundamental BCPLish flavour.

After a while, B. Stroustrup, a Danish guy that had been exposed
to Simula 67 at home, and to heavvvvy doses of BCPL and Algol68C
at Cambridge UK for his doctorate, joined Bell Labs, and started
working on a project called C with Classes, which eventually
extended C both with many Algol 68 and Simula 67 features.

   I will still argue vigorously that the Pascal family
   was founded on Algol-60 (consider the relative dates) but I
   admit that there's a case for tracing C casts and some aspects
   of its type system to Algol68.

Well, if you believe what I said above, Pascal was meant as an
*alternative* to Algol 60, and as a successor, it had a very
distinctly different flavour. Simula 67 and Algol 68 are the true
descendants of Algol 60. C has been much influenced by BCPL (of
course...)  which is a distant relation of Algol 68, by Algol 68
itself, and later on, C++ has been even more heavvily influenced
by Algol 68 and Simula 67. C has somewhat more than casts and
many aspects of its type system inspired by Algol 68 or Algol
68C.

Other interestiong notes: J. Ichbiah, the Ada man, had previously
worked a lot on Simula 67, somewhat on Algol 68, and developed an
implementation language whose ancestry seems to me clearly
derived from Algol 68 or Mary, called LIS, many of which features
popped up in Ada. Ada itself also contains a number of ideas
taken straight from Algol 68. A german university is now
distributing for very cheap a very portable Simula 67 compiler
that will also run on home micros... It may still make a comeback!

Algol 68 also influenced a lot of research into difficult topics
of programming language design and implementation; to this date,
papers on Algol 68 implementation make fascinating reading.

Frankly, Algol 68 is now all but dead, but if somebody, e.g.
Cambridge UK, were to release on the net, e.g. comp.sources.misc,
as freeware the Algol68{C} compiler (a *very* fine piece of
portable software) and its accessories and libraries and tools
etc..., I believe a lot of people in the USA and elsewhere could
rediscover its charms, and it could develop into a serious thing.
--
Piercarlo "Peter" Grandi           | ARPA: pcg%cs.aber.ac...@nsfnet-relay.ac.uk
Dept of CS, UCW Aberystwyth        | UUCP: ...!mcvax!ukc!aber-cs!pcg
Penglais, Aberystwyth SY23 3BZ, UK | INET: p...@cs.aber.ac.uk