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