Path: utzoo!attcan!uunet!lll-winken!lll-tis!ames!joyce!sri-unix!quintus!ok
From: ok@quintus.uucp (Richard A. O'Keefe)
Newsgroups: comp.lang.misc
Subject: Re: Algol 60 vs Algol 68 (was "stack machines (Burroughs)")
Message-ID: <141@quintus.UUCP>
Date: 28 Jun 88 03:01:49 GMT
References: <1521@pt.cs.cmu.edu> <1532@pt.cs.cmu.edu> <476@pcrat.UUCP> <130@quintus.UUCP> <961@gethen.UUCP>
Sender: news@quintus.UUCP
Reply-To: ok@quintus.UUCP (Richard A. O'Keefe)
Organization: Quintus Computer Systems, Inc.
Lines: 54

In article <961@gethen.UUCP> isaac@gethen.UUCP (Isaac Rabinovitch) writes:
>In article <130@quintus.UUCP>, ok@quintus.uucp (Richard A. O'Keefe) writes:
>> Ah, if only the committee had heeded the concerns of the Minority Report;
>> we might have had ADA _years_ earlier (:-).
>Hmm, I'm not too familiar with Ada, and it's been a long time since I
>used Algol W, but it seems to me that Algol W was a far simpler language.

Just so.  The Minority Report claimed that Algol 68 was directed at the
wrong issues and didn't provide the tools (modules &c) for building large
systems.  These were the same concerns that led eventually to ADA, after
a wasted decade had shown that Pascal was _not_ the answer.

>> The irony of it all is that Pascal is significantly crippled
>> with respect to Algol W.
>Could you expand on that point?
Arrays.  Algol W and Algol 68 were just about the last of the languages
whose designers thought that the "array" features of a language should
be influenced by the needs of "scientific" programmers rather than by
the addressing modes of the hardware.  (Dijkstra has also resisted the
"hardware rules" mentality, but do you see D-arrays going into the next
revision of Pascal, or into Fortran 8X?)  Even ADA basically just kludges
around Pascal's limits.

A digression on Algol 68 arrays.  You can do things like
	[1:n, 1:m] REAL a := read_array(n, m);
	# ... #
	[] REAL arow = a[i,:], acol = a[:,j];
	# ... #
	... arow[k] ...	# same as a[i,k] #
	... acol[k] ...	# same as a[k,j] #
Why is this useful?  After all, a good optimising compiler should notice
that a subscript remains constant and evaluate that part of the addressing
polynomial just once.  The usefulness of the feature is nothing to do with
whether it helps the compiler generate better code, though it may, but with
that fact that something I didn't write in the code is something I didn't
get wrong.  It's the same advantage that a[i,j,k] +:= 1 has; because I
didn't have to write the LHS twice, I missed one opportunity to make a mistake.

>> The essential ideas of Algol 68 were that the whole language should be
>> precisely defined and that all the pieces should fit together smoothly.
>Then they went and came up with the most complicated language definition
>ever, ruining any hopes of achieving that goal.

Nope, they didn't ruin any hopes whatsoever of achieving that goal.
Not a bit of it!  What they ruined was any hope of having many people
_realise_ that the goal had been met.  If you want to see a complicated
language definition, take the ANSI ADA specification and add the INRIA
formal definition of ADA (yet another definition which started by
inventing a new definition language).  I believe that the reason that
the moderately complex definition of Algol 68 scared people off but that
the ferociously complex definition of ADA hasn't is that people were
_shown_ the _whole_ Algol 68 definition, but not so ADA.  (Yes, the INRIA
definition never made it into the standard.  If you read comp.lang.ada you
will see that the result is that ADA in practice is about as ill-defined
as C.)