Late Bloomers Revisited

39 views
Skip to first unread message

Eric S. Raymond

unread,
Dec 13, 1989, 4:02:07 AM12/13/89
to
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. 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.

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

Followups to comp.lang.misc *only* this time...
--
Eric S. Raymond = er...@snark.uu.net (mad mastermind of TMN-Netnews)

Paul Campbell

unread,
Dec 14, 1989, 12:40:39 AM12/14/89
to
In article <1TmbNv#4mK14j=er...@snark.uu.net> er...@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. I will still argue vigorously that the Pascal family
>was founded on Algol-60 (consider the relative dates) but I admit that there's

Wirth (the 'father' of Pascal) was a member of the Algol68 committee, after
being involved in the design of the language he designed Pascal, he put in
many of the Algol68 features that were easy to implement and left out the
ones that were hard.

Paul

--
Paul Campbell UUCP: ..!mtxinu!taniwha!paul AppleLink: CAMPBELL.P
"We got a thousand points of light for the homeless man,
Got a kinder, gentler, machine gun hand ..." - Neil Young 'Freedom'

John W. Baugh Jr.

unread,
Dec 16, 1989, 12:10:16 PM12/16/89
to
In article <4...@taniwha.UUCP>, pa...@taniwha.UUCP (Paul Campbell) writes:
> Wirth (the 'father' of Pascal) was a member of the Algol68 committee, after
> being involved in the design of the language he designed Pascal, he put in

Unless I'm mistaken, I believe Wirth (and possibly Hoare) dissented
with the Algol-68 committee and proposed a simpler language, which was
essentially Algol-W (a nifty little language).

John Baugh (j...@cepmax.ncsu.edu)

Piercarlo Grandi

unread,
Dec 17, 1989, 1:43:50 PM12/17/89
to

In article <1TmbNv#4mK14j=er...@snark.uu.net> er...@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.abe...@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

L.J.Dickey

unread,
Dec 17, 1989, 3:15:06 PM12/17/89
to
In article <1TmbNv#4mK14j=er...@snark.uu.net> er...@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. 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.
|

I think you will find that C was derived from B (Bell?), which in turn
owes a lot to CPL and BCPL from Cambridge.

--
L. J. Dickey, Faculty of Mathematics, University of Waterloo.
ljdi...@water.UWaterloo.ca ljdi...@water.BITNET
ljdi...@water.UUCP ..!uunet!watmath!water!ljdickey
ljdi...@water.waterloo.edu

d...@alice.uucp

unread,
Dec 18, 1989, 1:28:46 AM12/18/89
to
Grandi's history of languages, <PCG.89De...@rupert.cs.aber.ac.uk>,
seems moderately plausible up until the part I know about directly. Perhaps
we have an effect like the one observed after Velikovsky's books:
the astronomers agreed that the astronomy was bogus, but some were impressed
by his history; some historians thought the opposite.

Specifics: Multics was sophisticated, but I would not call it
simple and efficient. There was never any plan to write it in BCPL
(this would be an anachronism if nothing else).

B (the name is an intersection of BCPL and Bonnie, Thompson's wife's
name) was done by Thompson at Bell Labs. Waterloo (the Canadian university)
got it much later, and made good use of it--to develop Eh and Zed,
for example, but this was a branch off the main line.

Bourne came to work at Bell Labs after C started, and stayed for
several years (rather more than just a visit). He didn't "influence"
the Bourne shell and adb, he wrote them.

To respond to the topic that started this discussion off: the type
structure of C was in fact profoundly influenced by Algol 68.
And all the languages mentioned are indeed descendants of Algol 60.

Dennis Ritchie
d...@research.att.com
att!research!dmr

Bjarne Stroustrup

unread,
Dec 18, 1989, 10:51:58 AM12/18/89
to


Simula was designed and implemented in Oslo, not Trondheim.

(maybe you got muddled up with Mary, that came from Trondheim?)

Also, I worked extensively with Simula at Cambridge.

Glen Ditchfield

unread,
Dec 18, 1989, 12:04:55 PM12/18/89
to
In article <PCG.89De...@rupert.cs.aber.ac.uk> p...@rupert.cs.aber.ac.uk (Piercarlo Grandi) writes:
>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!

It probably isn't the compiler that Mr. Grandi refers to, but a Lund
Simula compiler exists for the Macintosh. It runs under MPW,
and requires the MPW assembler. It is available for anonymous ftp from
rascal.ics.utexas.edu, in directory mac/programming/simula. A Hypercard
stack that comes with it contains the beginnings of a reference manual.

I have nothing to do with the U of Texas, Lund, or the compiler. I haven't
even had a chance to try it out yet.

Glen Ditchfield gjditc...@violet.uwaterloo.ca Office: DC 2517
Dept. of Computer Science, U of Waterloo, Waterloo, Ontario, Canada, N2L 3G1
Gorbachev is a CIA mole.

Andrew P. Mullhaupt

unread,
Dec 18, 1989, 12:34:38 PM12/18/89
to
In article <PCG.89De...@rupert.cs.aber.ac.uk>, p...@rupert.cs.aber.ac.uk (Piercarlo Grandi) writes:
>
> In article <1TmbNv#4mK14j=er...@snark.uu.net> er...@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?
>
To Eric: I think you may have been a little hasty...


| 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.
| --
To Peter:
True enough, but people are witnessing a rebirth of interest in
another 'dead' language (APL). I would like a copy of that Algol68
from Cambridge if I could have one for UNIX. The most likely use
would be to explore in a real environment, (i.e. 'off the blackboard')
what some of the data structuring ideas of Algol68 can bring to
our in-house language design efforts.

Later,
Andrew Mullhaupt

Dick Dunn

unread,
Dec 18, 1989, 2:23:01 PM12/18/89
to
p...@rupert.cs.aber.ac.uk (Piercarlo Grandi) wrote a long note about the
interrelationships of the Algols, Simula, Pascal, etc., but got some of the
history turned about.

Let's pick up about here...


> In Europe, two landmark events happened; Dahl, Dijkstra, Hoare

> authored "Structured Programming"...

You need to be careful about that one, because the three parts of _Struc-
tured_Programming_ have different origins and different real dates.

[vanWijngaarden's work]


> new technology for grammars that could be used to describe
> context sensitive aspects.

There are really two aspects to the work here. Remember (or note, if you're
fortunate enough not to remember:-) that the original Algol 68 report had
the two-level "vW" grammar, but used ordinary prose to describe "context
conditions". The revised report (circa 72?) pushed the grammar much
further.

> 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...

This is a bit backwards. Pascal was first out about 1970; _Structured_
_Programming_ was published after that. However, Hoare's work is properly
dated more like '65 (it just took a while to see print in _S_P_), and the
work itself certainly laid the basis for Pascal's type structure. I think
Hoare and Wirth were working closely at that time.

> 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.

Pascal was a result of the war, not the precipitator. There were several
candidate language proposals presented to WG2.1, and after very heated
dispute (Grandi calls it a "small war"; I would omit "small":-), those
favoring a simple language produced a sort of "minority report" and
eventually left the group. Pascal followed shortly thereafter.

> 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...

I'd say that BCPL had really become significant *before* the Pascal/
Algol 68 flap...although it was certainly alive and well then.

[moving to another part...]


> 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),...

That's what we know now as the "Bourne shell" - but this appeared circa
Version 7, which is very late 70's. The Bourne shell was by no means the
first /bin/sh.

>...the adb debugger,...

Don't forget that there was an Algol 68 implementation for V7 (by Bourne).
According to Bourne, adb was developed to help debug that implementation.

> I will still argue vigorously that the Pascal family

> was founded on Algol-60 (consider the relative dates)...
>...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...

Pascal was intended from the start to be a "small" language, and to have a
straightforward mapping onto the machine. Given that Pascal was first
implemented on CDC 6x00's, and given the grotesque, hideous, abysmal imple-
mentation of Algol 60 on that machine, I wonder what part of Wirth's atti-
tude to Algol 60 as a real language was formed by latter-day experience
with that implementation.

> 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...

Anyone seriously designing an algorithmic language post-1970 has to have
been influenced somehow by Algol 68. I wonder if some of the influences
from Algol 68, and more particularly from Mary (a wonderful bit of work)
could have come via Mark Rain, who was deeply involved in Mary and at least
peripherally involved in both Algol 68 and Green.
--
Dick Dunn r...@ico.isc.com uucp: {ncar,nbires}!ico!rcd (303)449-2870
...Never offend with style when you can offend with substance.

David Collier-Brown

unread,
Dec 20, 1989, 6:18:09 PM12/20/89
to
>In article <10...@alice.UUCP> d...@alice.UUCP writes:
> Specifics: Multics was sophisticated, but I would not call it
> simple and efficient.

p...@aber-cs.UUCP (Piercarlo Grandi) writes:
> Well, I beg to differ. Compared to things like VMS, System V, BSD Unix,
> etc..., Multics was remarkably small, simple, and fast. I find that a lot of
> people tend to forget that Multics run machines on which you would not today
> run GNU Emacs.

Alas, BSD 4.3 still isn't as large as Multics, although 4.4 may
make it (;-)).

As a former Multician (DRBrow...@HI-Mulics.ARPA) and still Multics
bigot, I have to agree with both peter and dmr.

It suffered from "sophistication", in that the primitives they picked
as being sufficent for the task were large, often complex "objects", usually
described properly as subsystems. They were, however, few in number and
conceptually simple, which made it easy to reason about once you got past
that first horrible case of information overload...
As to fast, it varied. The early releases bottlenecked seriously in
a number of areas (mostly due to implementation, phew!). Mine was a
release 9 on the DPS-8M hardware base and ran like a workstation (:-)).
Also, there was no such thing as a small configuration, which meant that
the machines usually got loaded with everybody and his brother as soon as
they arrived, lest the investment not pay off. Net result: 130 users and
fair to poor response.

To return to late blooming, I've seen a few of the good ideas quietly
resurface (memory mapped segments/files), and the bad ones (like small
segments: only 2^18 bytes) pop back up like a handfull of bad pennys. Ah
well, it just proves that he who knows not history is doomed to reinvent
it.
--dave

--
David Collier-Brown, | davecb@yunexus, ...!yunexus!davecb or
72 Abitibi Ave., | {toronto area...}lethe!dave
Willowdale, Ontario, | Joyce C-B:
CANADA. 416-223-8968 | He's so smart he's dumb.

Robert Firth

unread,
Dec 27, 1989, 10:00:24 AM12/27/89
to
In article <1989Dec18....@ico.isc.com> r...@ico.isc.com (Dick Dunn) writes:

>Pascal was a result of the war, not the precipitator.

...
>I'd say that BCPL had really become significant *before* the Pascal/
>Algol 68 flap...although it was certainly alive and well then.

The documents I think support both these assertions.

(1) The publication of record introducing Pascal is Acta Informatica
vol 1 pp 35-63, entitled 'The Programming Language Pascal'. The
journal most helpfully includes dates of submission as well as
dates of publication; it received Wirth's paper on 1970 October 30.

(2) The summary to the paper begins thus:

A programming language called Pascal is described
which was developed on the basis of Algol-60, its
range of applicability is considerably increased
due to a variety of data structuring facilities.

The language was developed by Wirth in the period 1969/70, after
he had broken with the Algol-6X group, and in part as an attempt
to demonstrate the feasability of his ideas, which, of course,
owe a lot to Algol-W and to Hoare's work on data structures.

(3) At the time of publication, there was one full Pascal compiler,
written in Pascal and executing on the CDC 6600. (This had
some bizarre consequences that still plague us, including the
line oriented IO, inherited alas by Ada.)

(4) By contrast, BCPL had reached the same stage four years earlier,
and by 1969 had been ported to the Titan at Cambridge. The
first edition of the Cambridge BCPL manual was issued in the
same year. The BCPL porting kit was issued in 1971; the date
on the accompanying compiler documentation is August 1971.

Incidentally, I have a copy of the Cambridge Algol-68C compiler.
It is indeed a fine piece of work, and much of it could profitably
be studied today.

Reply all
Reply to author
Forward
0 new messages