Path: utzoo!utgpu!jarvis.csri.toronto.edu!clyde.concordia.ca!uunet!mcsun!ukc!dcl-cs!aber-cs!pcg
From: pcg@aber-cs.UUCP (Piercarlo Grandi)
Newsgroups: comp.lang.misc
Subject: Re: Late Bloomers Revisited
Message-ID: <1517@aber-cs.UUCP>
Date: 19 Dec 89 19:04:40 GMT
Reply-To: pcg@cs.aber.ac.uk (Piercarlo Grandi)
Organization: Dept of CS, UCW Aberystwyth
	(Disclaimer: my statements are purely personal)
Lines: 70

In article <10248@alice.UUCP> dmr@alice.UUCP writes:
    
    Specifics: Multics was sophisticated, but I would not call it
    simple and efficient.

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. The architecture of Multics was remarkably elegant, and given
the few simple concepts employed and the relatively simple machine
architecture it was also efficient and simpel itself. The use of shared
libraries, memory mapped files, etc... was especially favourable.

Of course, as an example of *really* simple and efficient, I would put
forward V7 Unix (if one is content with its many limits), or MUSS, which is
actually as powerful as Multics, and smaller than Unix V7, and was designed
about the same time as Multics was. I have often thought that MUSS was what
Multics should have been. On the other hand, Multics is still far simpler
and more elegant and efficient than the latter day Unixes. Certainly
architecturally, API-wise, but also I think in implementation, e.g. I think
also in a simple measure of lines of code in the kernel.

    There was never any plan to write it in BCPL
    (this would be an anachronism if nothing else).

I was not there, and Dennis Ritchie was, but I seem to recollect reading
that the Multics project at MIT was started *before* PL/1 was designed, and
the MIT people, who had good links with Cambridge UK (and some with
Manchester), and were inspired by Atlas and Titan as well as CTSS, had
decided to use BCPL.

It was only after PL/1 was designed and looked like becoming a standard that
(apparently to please GE and BTL, the industrial partners) they decided to
switch to PL/1, and a first, half cooked, compiler for it was written from
scratch, *after* the BCPL had already been done. I sure remember having a
look at the Multics BCPL compiler and seeing that it seemed *very* old (and
nobody knew about it anyhow).

Anybody can tell whether my recollection of having read this is true?

    B (the name is an intersection of BCPL and Bonnie, Thompson's wife's
    name) was done by Thompson at Bell Labs.

Ooops. A slip. On the other hand, if I remember correctly, either Thompson
or Ritchie did study in a canadian University, and maybe this tripped my
memory.
    
    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.

Yes, yes. I used some understatement, or tongue-in-cheek, here and there
(e.g. describing the Algol 68 Pascal debate as merely a small war...).  I was
writing that Bourne's Algol68C experiences influenced very much both the sh
syntax and its source code (in later System Vs it has been de-Algol68fied
though), not to mention the fact that adb had an a68 stack trace command as
well as a c stack trace command ($a and $c respectively, if I remember
correctly).

    And all the languages mentioned are indeed descendants of Algol 60.

In an historical sense Pascal is as well, but I would like to maintain my
contention that Pascal's flavour is very different, and I would rather call
it a successor rather then a descendant. It belongs to the "algorithmic"
language family, and comes after Algol 60, but the style is profoundly
different.
-- 
Piercarlo "Peter" Grandi           | ARPA: pcg%cs.aber.ac.uk@nsfnet-relay.ac.uk
Dept of CS, UCW Aberystwyth        | UUCP: ...!mcvax!ukc!aber-cs!pcg
Penglais, Aberystwyth SY23 3BZ, UK | INET: pcg@cs.aber.ac.uk