wgh@ubbpc.UUCP (William G. Hutchison) (11/21/88)
In article <591@tuck.nott-cs.UUCP>, anw@nott-cs.UUCP writes: > In <391@ubbpc.UUCP>, wgh@ubbpc.UUCP (William G. Hutchison) writes, amongst > other things (in the Fortran group): > > > [ I presented the argument that good languages come from individuals, ] > > [ and bad designs come from committees: I quoted Algol-68 as one of ] > > [ several examples ] > > [ Andy Walker rebutted that his institution, Nottingham U, UK, used ] > [ Algol68 A WHOLE LOT, and they liked it A WHOLE LOT ] Andy, I now know of 2 (two) institutions that ever tried to use Algol-68 at all seriously, yours, and Math. Centrum in Amsterdam. If that is not an embarrassing debacle for a language design, what, pray tell, is? Ten million computer owners elected not to use Algol-68, and (order of magnitude) 2 institutions chose to use it. I realize that scientific truths are not decided democratically, by majority vote, otherwise one could say "Heroin is good, because millions of people use it frequently", but, my good man, give us a break. I submit that the reason an utterly negligible fraction of the computer owners in the world use Algol-68 is that the language design was inherently flawed, and it is my interpretation that these flaws stemmed from the committee-design process (primarily). The primary "benefit" that I see in your institutions' choice of Algol-68 is that you write programs that nobody else can use, and that your students have to do extra work learning mainstream languages after they graduate. That sounds like a bad decision on the part of Nottingham U. -- Bill Hutchison, DP Consultant rutgers!liberty!burdvax!ubbpc!wgh Unisys UNIX Portation Center "What one fool can do, another can!" P.O. Box 500, M.S. B121 Ancient Simian Proverb, quoted by Blue Bell, PA 19424 Sylvanus P. Thompson, in _Calculus Made Easy_
dik@cwi.nl (Dik T. Winter) (11/22/88)
In article <404@ubbpc.UUCP> wgh@ubbpc.UUCP (William G. Hutchison) writes: > In article <591@tuck.nott-cs.UUCP>, anw@nott-cs.UUCP writes: > > [ Andy Walker rebutted that his institution, Nottingham U, UK, used ] > > [ Algol68 A WHOLE LOT, and they liked it A WHOLE LOT ] > > Andy, I now know of 2 (two) institutions that ever tried to use Algol-68 at > all seriously, yours, and Math. Centrum in Amsterdam. > If that is not an embarrassing debacle for a language design, what, pray tell, > is? Ten million computer owners elected not to use Algol-68, and (order of > magnitude) 2 institutions chose to use it. Strange that a (semi-commercial) corporation like NAG has produced a complete numerical library for Algol-68 if only 2 institutes used it! (And that library had not very much followers here.) To be true, there is one country where Algol-68 has been used a lot: the UK. Of course the availability of compilers made a big difference (Algol-68C from Cambridge etc.). -- dik t. winter, cwi, amsterdam, nederland INTERNET : dik@cwi.nl BITNET/EARN: dik@mcvax
firth@sei.cmu.edu (Robert Firth) (11/22/88)
In article <404@ubbpc.UUCP> wgh@ubbpc.UUCP (William G. Hutchison) writes: > Andy, I now know of 2 (two) institutions that ever tried to use Algol-68 at >all seriously, yours, and Math. Centrum in Amsterdam. > If that is not an embarrassing debacle for a language design, what, pray tell, >is? Ten million computer owners elected not to use Algol-68, and (order of >magnitude) 2 institutions chose to use it. Please add the following institutions, all of which either used or taught Algol-68: University of Oxford University of Cambridge University of London Royal Signals and Radar Establishment Royal Military College of Science However, a better test of the language as a piece of design is the number of key concepts it introduced. This includes formal definition of static semantics using a van-Wyngaarden grammar fully orthogonal type system with code objects as first-class objects user-defined operators and operator overloading a clear and correct definition of coercion the "heap" array slicing in a more powerful and more well-founded manner well, I won't run on too long, but Algol-68 has an honourable place even in a history written by the "winners".
nick@ccicpg.UUCP (Nick Crossley) (11/22/88)
In article <404@ubbpc.UUCP> wgh@ubbpc.UUCP (William G. Hutchison) writes: >> [ Andy Walker rebutted that his institution, Nottingham U, UK, used ] >> [ Algol68 A WHOLE LOT, and they liked it A WHOLE LOT ] > > Andy, I now know of 2 (two) institutions that ever tried to use Algol-68 at >all seriously, yours, and Math. Centrum in Amsterdam. Add at least two more to your limited knowledge: the Royal Radar Establishment and Cambridge University, UK. RRE produced a compiler for the ICL 1900 machines; their system is described in "ALGOL68-R Users Guide", by PM Woodward and SG Bond, HMSO 1974, ISBN 0-11-771600-6. A version of this was also ported to the later 2900 range. At Cambridge University, we had a compiler for Algol68C (Algol68 with some extensions) which was heavily used. Most (all?) of the operating system for the CAP machine was written in Algol68C. This project is described in the book "The Cambridge CAP Computer and its Operating System", by MV Wilkes and RM Needham, North-Holland 1979, ISBN 0-444-00357-6. I quote from the preface: "The choice of a programming language for an operating system is a crucial one. ... As a system programming language Algol68C has proved a distinct success." The book gives several example modules from the CAP OS. The Algol68C compiler was also sent to several other Universities. > I submit that the reason an utterly negligible fraction of the computer >owners in the world use Algol-68 is that the language design was inherently >flawed, and it is my interpretation that these flaws stemmed from the >committee-design process (primarily). Algol68 is one of the very few languages whose design is inherently sound. It has one of the most regular and predictable syntaxes of any of todays languages. The lack of more widespread use is probably due more to possible difficulties of complete implementation, and because it was never adopted by some commercial hardware/software vendor. > The primary "benefit" that I see in your institutions' choice of Algol-68 is >that you write programs that nobody else can use, and that your students have >to do extra work learning mainstream languages after they graduate. > That sounds like a bad decision on the part of Nottingham U. >-- >Bill Hutchison, DP Consultant rutgers!liberty!burdvax!ubbpc!wgh >Unisys UNIX Portation Center "What one fool can do, another can!" >P.O. Box 500, M.S. B121 Ancient Simian Proverb, quoted by >Blue Bell, PA 19424 Sylvanus P. Thompson, in _Calculus Made Easy_ This is rubbish. Programs written is Algol68 can be extremely readable - MUCH more so than C. Learning Algol68 would give students a clearer idea of data structures than many other languages, I believe. And how many serious programmers know only one language? A knowledge of several languages helps students understand the principles behind them more easily; Algol68 should be included in this set as it makes many of those principles very clear. Furthermore, in these days when software reliability is so important, I would maintain that few languages have the potential for reliability that Algol68 has. -- <<< standard disclaimers >>> Nick Crossley, CCI, 9801 Muirlands, Irvine, CA 92718-2521, USA Tel. (714) 458-7282, uucp: ...!uunet!ccicpg!nick
elg@killer.DALLAS.TX.US (Eric Green) (11/22/88)
in article <404@ubbpc.UUCP>, wgh@ubbpc.UUCP (William G. Hutchison) says: > In article <591@tuck.nott-cs.UUCP>, anw@nott-cs.UUCP writes: >> In <391@ubbpc.UUCP>, wgh@ubbpc.UUCP (William G. Hutchison) writes, amongst >> other things (in the Fortran group): >> > [ I presented the argument that good languages come from individuals, ] >> > [ and bad designs come from committees: I quoted Algol-68 as one of ] >> > [ several examples ] > Andy, I now know of 2 (two) institutions that ever tried to use Algol-68 at > all seriously, yours, and Math. Centrum in Amsterdam. Actually, Algol-68 was used by many European universities. It never caught on here in the States, but that's mainly because the foremost languages here in the States Cobol and Fortran (no joke!), except in the high-end CS programs, which used Lisp or, if they used an Algol-like language, PL/1. Saying, then, that Algol-68 was an "embarassing debacle" is assuming an attitude of American ethnocentricism which is, in itself, embarrasing. > I submit that the reason an utterly negligible fraction of the computer > owners in the world use Algol-68 is that the language design was inherently > flawed, and it is my interpretation that these flaws stemmed from the > committee-design process (primarily). From what I've seen of Algol-68 (admittedly not much), the language design's flaws are related more to the implementability of certain language features, and the "trickiness" of using the language to its full extent... as far as language size and definition goes, I see little difference between the language defintion of Algol-68 and, say, Modula-][. > Bill Hutchison, DP Consultant rutgers!liberty!burdvax!ubbpc!wgh > Unisys UNIX Portation Center "What one fool can do, another can!" Somehow, when I read the words "Unix Portation Center", I can't get the image of a pontoon bridge out of my mind ;-). (sorry, you have to be raised on old WW][ films to know what I'm talking about). -- Eric Lee Green ..!{ames,decwrl,mit-eddie,osu-cis}!killer!elg Snail Mail P.O. Box 92191 Lafayette, LA 70509
ok@quintus.uucp (Richard A. O'Keefe) (11/22/88)
In article <404@ubbpc.UUCP> wgh@ubbpc.UUCP (William G. Hutchison) writes: > Andy, I now know of 2 (two) institutions that ever tried to use Algol-68 at >all seriously, yours, and Math. Centrum in Amsterdam. How about Cambridge, where the Algol-68C compiler came from (the one I used to use)? How about RRE? How about the use of Algol 68 on one of the CMU parallel machines? What, exactly, were the flaws in the language _design_? (I will agree that formats were rather too complicated -- having had Algol 60 slammed for not having I/O built in the '68 team tried to out-Fortran Fortran. And today C is popular, oh the shame of it.) I contend that Algol 68 was a simple language with a complicated _description_ which frightened a lot of people. Pascal was a hideously complex language (special cases and special caveats all over the place, UGH) with a deceptively simple _description_ which suckered a lot of people. Whenever I got the Algol 68C compiler to accept a program, it did exactly what I thought it would (modulo my mistakes). But not only was it harder to express even the simplest thing in Pascal (matrix multiplication, for example), for many years every Pascal compiler located a different _large_ area of uncertainty about what Pascal was supposed to mean. First it got to the point where I stopped using FOR statements, because I couldn't find two Pascal compilers that did the same thing with them, and then I gave up trying to port Pascal programs entirely and rewrote them in C. -- Subjects considered Mexico to be more similar to the United States than the United States is to Mexico -- George Lakoff.
jack@cs.glasgow.ac.uk (Jack Campin) (11/22/88)
wgh@ubbpc.UUCP (William G. Hutchison) wrote: > [ Andy Walker rebutted that his institution, Nottingham U, UK, used ] > [ Algol68 A WHOLE LOT, and they liked it A WHOLE LOT ] > Andy, I now know of 2 (two) institutions that ever tried to use Algol-68 at > all seriously, yours, and Math. Centrum in Amsterdam... > I submit that the reason an utterly negligible fraction of the computer > owners in the world use Algol-68 is that the language design was inherently > flawed... ICL used S3, a dialect of Algol 68, to write their VME operating system, a HUGE program. On their machine architecture (not unlike the Burroughs stack machines) it runs phenomenally fast. Mor importantly, Algol 68 continues to inspire clean language designs - its concern for orthogonality is reflected in ML, most lazy functional languages, Smalltalk, PS-algol, FAD,... and what did Pascal and C lead to? Ada and C++, both messed up with piles of ad hoc restrictions that are absolutely unintelligible without knowing how the compiler and run-time systems work. This is how to design a high-level language? -- ARPA: jack%cs.glasgow.ac.uk@nss.cs.ucl.ac.uk USENET: jack@cs.glasgow.uucp JANET:jack@uk.ac.glasgow.cs useBANGnet: ...mcvax!ukc!cs.glasgow.ac.uk!jack Mail: Jack Campin, Computing Science Dept., Glasgow Univ., 17 Lilybank Gardens, Glasgow G12 8QQ, SCOTLAND work 041 339 8855 x 6045; home 041 556 1878
mct@praxis.co.uk (Martyn Thomas) (11/23/88)
Praxis still uses Algol 68, for real product development. We compile through the SD-SCICON Algol 68 compiler for VAX systems, and through our own compiler to C for Suns and other UNIX systems. ICL supply Algol 68 as a standard product to run on VME. We can supply for Honeywell Multics, if anyone is still running it! The Royal Signals and Radar Establishment have a compiler for FLEX (their capability machine), and for Ten15 (their abstract machine). A new implementation for any reasonable architecture should cost less than #500,000 (UK pounds), starting from the RS front-end. We are happy to bid for such implementation contracts! Martyn Thomas, Praxis plc, 20 Manvers Street, Bath BA1 1PX UK. Tel: +44-225-444700. Email: ...!uunet!mcvax!ukc!praxis!mct
john@frog.UUCP (John Woods) (11/23/88)
In article <404@ubbpc.UUCP>, wgh@ubbpc.UUCP (William G. Hutchison) writes: > The primary "benefit" that I see in your institutions' choice of Algol-68 is >that you write programs that nobody else can use, and that your students have >to do extra work learning mainstream languages after they graduate. > That sounds like a bad decision on the part of Nottingham U. Teaching Algol-68 allows many institutions to expose their students to interesting concepts in the design of computer languages. Evidently you prefer that they expose students only to BOTH concepts present in PASCAL (straight jackets and rubber walls), so they can turn out the future COBOL-drudges. "Thunk" is not the sound of a PC hitting a desk. -- John Woods, Charles River Data Systems, Framingham MA, (617) 626-1101 ...!decvax!frog!john, john@frog.UUCP, ...!mit-eddie!jfw, jfw@eddie.mit.edu Science does not remove the TERROR of the Gods!
smryan@garth.UUCP (Steven Ryan) (11/24/88)
I envy all you across the Atlantic. On this side of the big shining water we're
debating whether C or Fortran is better.
--
-- s m ryan
--------------------------------------------------------------------------------
As loners, Ramdoves are ineffective in making intelligent decisions, but in
groups or wings or squadrons or whatever term is used, they respond with an
esprit de corps, precision, and, above all, a ruthlessness...not hatefulness,
that implies a wide ranging emotional pattern, just a blind, unemotional
devotion to doing the job.....haynes@ucscc.UCSC.EDU (99700000) (11/24/88)
When I needed to learn Fortran they handed me a copy of Dan McCracken's
introductory book on Fortran programming and I was writing usable
programs in a day or so.
When Dartmouth BASIC became available they handed me a thin pamphlet
and I was writing usable programs a few minutes later.
When Algol 60 became available and I wanted to learn it they handed me
a description of the language written in BNF. Or maybe it was a copy
of the CACM article. It was quite a while before I got an Algol
program to compile successfully, much less do anything useful in my
work.
When Algol 68 was defined (by then I was using PL/1 a lot) all I could get
was a book ten times as incomprehensible as the Algol 60 report. And it
was several years later before somebody might have had a compiler
that I could have used; I didn't bother trying to find out.
Many of us want to get our work done, not to learn a language for its
own sake. ("An engineer is someone who does list processing in Fortran",
V. Michael Powers, Naval Postgraduate School) Extrapolating from my
own experience, I'd say the popularity of a language, notwithstanding
its intrinsic merit, depends on
a. a good book for self-study, with lots of examples
b. access to a compiler for the language
c. classroom instruction is a very distant third
d. amount of effort required to get a program started. (When I started
learning Cobol one of the first programs I wrote was a program to
prefabricate as much as possible of the "boiler plate" needed to write
a Cobol program.)
haynes@ucscc.ucsc.edu
haynes@ucscc.bitnet
..ucbvax!ucscc!haynes
"Any clod can have the facts, but having opinions is an Art."
Charles McCabe, San Francisco Chronicleandy@ecrcvax.UUCP (Andrew Dwelly) (11/24/88)
In article <1916@crete.cs.glasgow.ac.uk> jack@cs.glasgow.ac.uk (Jack Campin) writes: >More importantly, Algol 68 continues to inspire clean language designs - its >concern for orthogonality is reflected in ML, most lazy functional languages, >Smalltalk, PS-algol, FAD,... Design influences on languages is a subject on which we could speculate endlessly. For example it seems to me that the influence of `Algol type languages' on functional languages is pretty minimal. Their orthogonality seems to arise fairly naturally from the power and elegance of the underlying formalism (Lambda calculus). Unfortunately, I've never been exposed to Algol-68, so I'm curious, was it strongly or polymorphicly typed ? I know Strachey introduced the concept at round about this time. Andrew Dwelly E.C.R.C. UUCP: mcvax!unido!ecrcvax!andy ArabellaStrasse 17 or pyramid!ecrcvax!andy D-8000 Muenchen 81, West Germany UUCP Domain: andy@ecrcvax.UUCP [Bump, Crash ...... Listen; who swears ? Christopher Robin has fallen down stairs.]
chl@r1.uucp (Charles Lindsey) (11/25/88)
In article <404@ubbpc.UUCP> wgh@ubbpc.UUCP (William G. Hutchison) writes: >In article <591@tuck.nott-cs.UUCP>, anw@nott-cs.UUCP writes: >> In <391@ubbpc.UUCP>, wgh@ubbpc.UUCP (William G. Hutchison) writes: >> > [ I presented the argument that good languages come from individuals, ] >> > [ and bad designs come from committees: I quoted Algol-68 ... >> [ Andy Walker rebutted that his institution, Nottingham U, UK, used ] >> [ Algol68 A WHOLE LOT, and they liked it A WHOLE LOT ] > > Andy, I now know of 2 (two) institutions that ever tried to use Algol-68 at >all seriously, yours, and Math. Centrum in Amsterdam. No, there were maybe a dozen Universities (notably Liverpool) in the UK who used it as a first programming language (one or two still do). RSRE at Malvern (a Govt. Research Establishment) used it almost exclusively (and still do to a significant extent). For numerical work, a whole special edition of the NAG Library was written to go with it. It was used at various places in Europe, particularly where CDC machines were used (CDC was the only manufacturer ever to produce a proper implementation). Currently, there is significant use in the Soviet Union (they even have a Russian Standard in preparation). I have a recent letter from G.S.Tseytin at Leningrad describing the present Soviet implementations, which I could post to the network if anyone is interested. >I submit that the reason an utterly negligible fraction of the computer >owners in the world use Algol-68 is that the language design was inherently >flawed, and it is my interpretation that these flaws stemmed from the >committee-design process (primarily). If Bill Hitchison thinks the language is "flawed" then he should say what the flaws are. And if he does not understand the language well enough to be aware of them, then he should not make such rash statements. The truth is that such murky corners as exist in ALGOL 68 (every language has some of them) are buried an order of magnitude deeper than in any other language. The beauty of writing programs in it is that you do not have to waste your time fighting language features which do not do "quite what you want". The reason it didn't catch on was the lack of compilers (I admit, it is a swine to implement, and those few murky corners which only implementors ever see are largely to blame). Also, the few compilers that did get written were not particularly portable (portability was not so fashionable in those days). Actually, ALGOL 68 was not designed by a committee at all. It was designed by four people in Amsterdam with a backup team in Brussels checking their work. Although a parent committee did exist (IFIP WG2.1), it had no meeting between May 1967 and June 1968 during which period the real cleanliness and "orthogonality" of the work was put in place. The committee got all the language features it asked for, but the Style arose from the strong personality of its chief Editor. Admittedly, there was much controversy and a famous bust-up of the committee at the end of 1968, but the essentials of the Orthogonal Style survived. When it came to revision of the language between 1972 and 1974, the team had increased to 8 people, but only four of us were really active in the work. I must say that we had a wonderful cooperation (even though most of it was done by transatlantic snail mail). I would say that this was about the optimal size of team for such a venture - you need several people to put in ideas, and to cross-check each other's work. Again, we were criticised for the size and obscurity of our Report but (apart from the Transput, which admittedly was weak, the number of known bugs in the main part of the definition can be counted on the fingers of one hand). And since then, far larger and less reliable language definitions have become commonplace. > ... and that your students have >to do extra work learning mainstream languages after they graduate. No. The whole point is that a student brought up on a really clean language will be able to see the flaws in whatever he eventually meets in real life. If all he has ever seen is PASCAL, or BASIC, or FORTRAN, then he will imagine that the world really is a horrible place and he will not yearn for anything better. Charles Lindsey chl@ux.cs.man.ac.uk.uucp
keith@mva.cs.liv.ac.uk (11/25/88)
In article <7774@aw.sei.cmu.edu>, firth@sei.cmu.edu (Robert Firth) writes: > Please add the following institutions, all of which either used or taught > Algol-68: > > University of Oxford > University of Cambridge > University of London > Royal Signals and Radar Establishment > Royal Military College of Science Add University of Liverpool, Dept. CS, Dept. SCM Algol68 R (ICL 1906S) - now defunct as of 1984 Algol68 S (Modular One) - '' ditto '' Algol68 RS (VAX/VMS) - defunct as of 1988 - moved to Irvine ADA on HP 850 and 300 series. FLACC Algol68 (VM/CMS) still in use as a teaching language until next year. > However, a better test of the language as a piece of design is the number > > of key concepts it introduced. This includes > > formal definition of static semantics using a van-Wingaarden grammar ~~~~~~~~~~~~~~~~~~~~~~ I think this was part of the reason Algol68 never caught on. Compiler writers were too lazy to learn how to read the revised report. I found it to be a refreshing change to to elastic bands, glue and tippex styles used for other LRMs/definitions. The template on which Ada is founded was reputedly Pascal. Ada might not have been subject to the controversy it has generated if its basis had been Algol68 (Hell, we could have called it Algol-88 or something). Keith Keith Halewood Janet: KEITH@UK.AC.LIV.CS.MVA Internet: KEITH%MVA.CS.LIV.AC.UK@CUNYVM.CUNY.EDU UUCP: ...!mcvax!ukc!mupsy!liv-cs!keith "When it comes to glittering objects, wizards have all the taste and self-control of a deranged magpie" - Terry Pratchett's "Sourcery"
firth@sei.cmu.edu (Robert Firth) (11/26/88)
In article <5581@saturn.ucsc.edu> haynes@ucscc.UCSC.EDU (Jim Haynes) writes: >When Algol 68 was defined (by then I was using PL/1 a lot) all I could get >was a book ten times as incomprehensible as the Algol 60 report. And it >was several years later before somebody might have had a compiler >that I could have used; I didn't bother trying to find out. Then you were very unlucky. When Algol-68 came out, you could have read Lindsay & van der Moelen's excellent "Informal Introduction to Algol-68", which in my opinion is as lucid a language manual as any programmer would ever wish to meet, with examples illustrating every point made. Within 15 months, you could have been programming in Algol-68 using the excellent Algol-68R compiler from the Royal Radar Establishment. This implemented all the language except the parallel processing features, ran at high speed, and produced better code than the then current Fortran IV compiler. It also came with a "Users Guide" of just 64 typed pages, which again was a model of clarity. Its first example is given on page 1: BEGIN INT i,j; read((i,j)); print(64/(i+j)) END which was the first Algol-68 program I ever got working, and it took me an afternoon (10 minutes on the program and the rest spent finding someone who could help me with ICL 1900 Job Control Language). Within 24 months, you could have taken delivery of the Cambridge University Algol-68C portable compiler, and had real fun.
ok@quintus.uucp (Richard A. O'Keefe) (11/26/88)
In article <5581@saturn.ucsc.edu> haynes@ucscc.UCSC.EDU (Jim Haynes) writes: >When Algol 68 was defined (by then I was using PL/1 a lot) all I could get >was a book ten times as incomprehensible as the Algol 60 report. You should have been given a copy of the article "Algol 68 with Fewer Tears". I forget the title, but it appeared in the Computer Journal. Shorter than the Algol 60 report, but covered the main points. There was a superb book "Premier Pas en Programmation" which used Algol 68 as a first language; I was particularly taken with the way the author managed to cover recursion simply and clearly before he got to assignment. The Lindsey & van der Meulen book "Informal Introduction to Algol 68" has an introductory chapter "Very Informal Introduction to Algol 68" which was pretty clear. There was some good introductory stuff for Algol 68R as well. By the way, that's PL/I, not PL/1. Now _there's_ a complicated language! (IBM's Checkout and Optimising compilers implemented different languages...)
cmt@myrias.UUCP (Chris Thomson) (11/27/88)
In article <5495@mva.cs.liv.ac.uk> keith@mva.cs.liv.ac.uk writes: >Add University of Liverpool, Dept. CS, Dept. SCM > Algol68 R (ICL 1906S) - now defunct as of 1984 > Algol68 S (Modular One) - '' ditto '' > Algol68 RS (VAX/VMS) - defunct as of 1988 - > moved to Irvine ADA on HP 850 and 300 series. > FLACC Algol68 (VM/CMS) still in use as a teaching language until > next year. Wow! FLACC outlived all those. If you'd predicted that when Colin and I were writing it, I'd have laughed. You know, we only ever got 22 copies installed, and less than 5 of those in North America. Even though it ran on 370's under MVS, CMS and MTS, and was cheap and reliable. Talk about a marketing disaster. -- Chris Thomson, Myrias Research Corporation uunet!ncc!myrias!cmt 900 10611 98 Ave, Edmonton Alberta, Canada 403-428-1616 formerly with Chion Corporation
mct@praxis.co.uk (Martyn Thomas) (11/28/88)
In article <404@ubbpc.UUCP>, wgh@ubbpc.UUCP (William G. Hutchison) writes: > The primary "benefit" that I see in your institutions' choice of Algol-68 is >that you write programs that nobody else can use, and that your students have >to do extra work learning mainstream languages after they graduate. > That sounds like a bad decision on the part of Nottingham U. Research at MC-Amsterdam by van der Meulen (if my memory is accurate) showed that learning Algol 68 greatly reduced the time to learn subsequent languages, and that if you have to learn more than two languages, starting with Algol 68 reduced the overall learning time for the other languages by more than the time taken for Algol 68. I'll post the reference if I can locate it. Martyn Thomas, Praxis plc, 20 Manvers Street, Bath BA1 1PX UK. Tel: +44-225-444700. Email: ...!uunet!mcvax!ukc!praxis!mct
wgh@ubbpc.UUCP (William G. Hutchison) (11/28/88)
In article <7724@boring.cwi.nl>, dik@cwi.nl (Dik T. Winter) writes: > In article <404@ubbpc.UUCP> wgh@ubbpc.UUCP (William G. Hutchison) writes: > > In article <591@tuck.nott-cs.UUCP>, anw@nott-cs.UUCP writes: > > > [ Andy Walker rebutted that his institution, Nottingham U, UK, used ] > > > [ Algol68 A WHOLE LOT, and they liked it A WHOLE LOT ] > > Andy, I now know of 2 (two) institutions that ever tried to use Algol-68 > > seriously, yours, and Math. Centrum in Amsterdam. > > If that is not an embarrassing debacle for a language design, what > > is? Ten million computer owners elected not to use Algol-68, and (order of > > magnitude) 2 institutions chose to use it. > Strange that a (semi-commercial) corporation like NAG has produced a complete > numerical library for Algol-68 if only 2 institutes used it! Thanks for the update. Before we get embroiled in a meaningless argument, let me point out that there are at least two criteria for success of a programming language: success-1: having lots of neat design ideas, and success-2: being widely adopted. So Algol-60 had success-1, but failure-2, since it never caught on outside of Europe. I thought of Algol-68 as failure-1 (because of the baroque, unusable language spec), and failure-2 (because a negligible part of the computer community uses it). Enough people have responded that I may revise my opinion and decide that Algol-68 had success-1, but there is no evidence that it had success-2. Here are some more opinions: Ada success-1? failure-2? small group (Ichbiah & Co.)? Algol-60 success-1 failure-2 small group Algol-68 success-1?? failure-2 committee C success-1 success-2 small group COBOL failure-1 success-2 committee FORTRAN failure-1 success-2 small group FORTH failure-1 success-2? small group LISP success-1 failure-2(this is changing) small group Modula2 success-1 success-2 small group Pascal success-1 success-2 small group PL/I failure-1 failure-2 large committee (I need more info about Ada: did a small group around Ichbiah define most of the language, or does it qualify as a committee design? Also, I do not honestly know if Ada qualifies as a success yet.) I still maintain that this supports my earlier thesis: that committee- designed languages fail and individually-designed languages succeed. Now that I have defined success and failure more clearly, more people might agree. -- Bill Hutchison, DP Consultant rutgers!liberty!burdvax!ubbpc!wgh Unisys UNIX Portation Center "What one fool can do, another can!" P.O. Box 500, M.S. B121 Ancient Simian Proverb, quoted by Blue Bell, PA 19424 Sylvanus P. Thompson, in _Calculus Made Easy_
anw@nott-cs.UUCP (11/28/88)
In article <404@ubbpc.UUCP> wgh@ubbpc.UUCP (William G. Hutchison) writes: [ignores all the arguments, reasons, facts and opinions in my previous article, and tries to wriggle out with ...] > Andy, I now know of 2 (two) institutions that ever tried to use Algol-68 at >all seriously, yours, and Math. Centrum in Amsterdam. Well, if your mail and news directories have been as full as mine, you now know of a few more; I could (fairly) easily run up another hundred or so, based on published papers, attendance at conferences, personal contacts, etc. > If that is not an embarrassing debacle for a language design, what, pray tell, ^^^^^^ This is shifting the ground somewhat, but let that pass ... >is? Ten million computer owners elected not to use Algol-68, and (order of >magnitude) 2 institutions chose to use it. We now all know that 2 is not the right OOM. It should be pointed out that nor is 10000000. We're talking about the early 70's, when computers were mainframes, rare, hideously expensive, and located in computing centres with large staffs. [I realise that *some* places are *still* like that!] Ordinary users didn't get much chance to "elect" whether or not to use any particular language; they were stuck with what their CC provided. > I submit that the reason an utterly negligible fraction of the computer >owners in the world use Algol-68 is that the language design was inherently >flawed, and it is my interpretation that these flaws stemmed from the >committee-design process (primarily). I suggest you point to such a flaw, and then we can perhaps discuss it sensibly. > The primary "benefit" that I see in your institutions' choice of Algol-68 is >that you write programs that nobody else can use, and that your students have >to do extra work learning mainstream languages after they graduate. This worried us at the time. We talked to many prospective employers of our graduates. *Without exception* they said: "Teach what you like. We will teach them Fortran or Cobol or whatever. They will have to adapt to our coding standards, hardware, operating system, etc, etc; they might just as well adapt to our software as well. Please send us graduates who are computer literate, and who know how to think." Would the Unisys UNIX Portation Center's advice have been different? No ex-student has ever returned to complain about the time "wasted" learning Algol 68; many have said how much they appreciated Algol once they had been forced to learn "inferior" languages. -- Andy Walker, Maths Dept., Nott'm Univ., UK. anw@maths.nott.ac.uk
khb%chiba@Sun.COM (Keith Bierman - Sun Tactical Engineering) (11/29/88)
In article <406@ubbpc.UUCP> wgh@ubbpc.UUCP (William G. Hutchison) writes: >Before we get embroiled in a meaningless argument, let me point out that there >are at least two criteria for success of a programming language: > success-1: having lots of neat design ideas, and > success-2: being widely adopted. text deleted re-ordered > I still maintain that this supports my earlier thesis: that committee- >designed languages fail and individually-designed languages succeed. Now that >I have defined success and failure more clearly, more people might agree. I appreciate your clarification of success, but I think your thesis remains unsupported. > > Here are some more opinions: > >Ada success-1? failure-2? small group (Ichbiah & Co.)? too early to tell, but since commercial shops are chosing it for new work (not yet in droves though) it may very well be a success-2. I would have classified Ada as a committee >Algol-60 success-1 failure-2 small group >Algol-68 success-1?? failure-2 committee Using US success as criteria for -2 seems a bit parochial >C success-1 success-2 small group >COBOL failure-1 success-2 committee COBOL did much right (as little as I like to admit it), failure-1 is not totally justified. >FORTRAN failure-1 success-2 small group FORTRAN was tied for first "high level language"...given its early appearance the original fortran should be classed as success-1. F88, while imperfect does (in the opnion of some) deserve a success-1. >FORTH failure-1 success-2? small group failure-2. >LISP success-1 failure-2(this is changing) small group "changing" not much in the big scheme of things... and its current form is the product of committee work. >Modula2 success-1 success-2 small group Failure-2. Perhaps this will change. Seperate i/o modules for each datatype and etc. make modula-2 an ugly language for applications ... whether there is a need for yet another systems programming language is debatable. >Pascal success-1 success-2 small group success-1 ?? Nearly every single early implementation had to massively extend it to make it useful. Code portability was nil, and etc. >PL/I failure-1 failure-2 large committee > The contention that committees have done worse than small groups is not supported by this simple tabulation. Futhermore if we weight the "votes" by the lines of code (or programmers fluent, or any other metric of size) committee designed languages had done much better. Keith H. Bierman It's Not My Fault ---- I Voted for Bill & Opus
ok@quintus.uucp (Richard A. O'Keefe) (11/29/88)
In article <406@ubbpc.UUCP> wgh@ubbpc.UUCP (William G. Hutchison) writes: > Here are some more opinions: > >Ada success-1? failure-2? small group (Ichbiah & Co.)? VERY LARGE GROUP. >Algol-60 success-1 failure-2 small group >Algol-68 success-1?? failure-2 committee >C success-1 success-2 small group >COBOL failure-1 success-2 committee >FORTRAN failure-1 success-2 small group >FORTH failure-1 success-2? small group >LISP success-1 failure-2(this is changing) small group >Modula2 success-1 success-2 small group >Pascal success-1 success-2 small group >PL/I failure-1 failure-2 large committee Ada came out of a long design process involving a lot of people. There were at least 5 iterations of the *requirements* document (StrawMan, WoodenMan, TinMan, IronMan, SteelMan). Several teams produced designs. Red, Blue, Green, and Yellow drafts were published in SigPlan notices. After the first Ada spec was produced, there was a review period when thousands of comments were sent in from all over the world (e.g. a friend and I logged in from Edinburgh over the Arpanet, scanned the comments on a particular section, and found that our comment had already been made). There are few new ideas in Ada the way there were in the other languages. (Why are CHILL, CLU, Alphard, LIS, to name but a few of the languages which influenced Ada, omitted from the table?) Again, Modula2 was not an innovative language. It was basically a clean-up of Modula. (Same designer. I'm not saying the designer isn't innovative!) I can think of no ideas in Pascal that don't predate it, only limitations. (Think of Simula 67, Algol W, CPL, MadCap, ...) PL/I is available on (some) UniSys machines, PR1MEs, VAXen, MIPSco machines, ... It was one of the first "algebraic" languages to include halfway clean allocate/free, first well-known language to have exception handling (other than COBOL's tests which must be attached to the statements which might cause the exception), generic procedures, array cross-sections, ... [Many of these ideas had been around, but PL/I put them together in one package which a major manufacturer was committed to.] How about Simula-67, which introduced the Class concept? How about APL? There are probably more people using Ada now than APL. > I still maintain that this supports my earlier thesis: that committee- >designed languages fail and individually-designed languages succeed. Now that >I have defined success and failure more clearly, more people might agree. There are two issues: (a) if a single designer can't hold the whole language in his head, there is little reason to expect someone using the language to do so. With a lot of people putting things into a language, there is a fair chance that none of them will understand all the interactions. (b) however, it is only possible to set up a large committee if there is already a lot of commitment to the language in advance (COBOL, Ada, Fortran 8X, even PL/I). So such a design will have a lot of political momentum whatever its technical (de)merits. The really awful thing is when you have a language designed by a small group which is taken over by a committee who don't really understand it, but keep me off _that_ subject...
wgh@ubbpc.UUCP (William G. Hutchison) (11/29/88)
In article <5495@mva.cs.liv.ac.uk>, keith@mva.cs.liv.ac.uk writes: > In article <7774@aw.sei.cmu.edu>, firth@sei.cmu.edu (Robert Firth) writes: > > Please add the following institutions, all of which either used or taught > > Algol-68: U. of Oxford, U. of Cambridge, U. of London > > Royal Signals and Radar Establishment, Royal Military College of Science > Add University of Liverpool, Dept. CS, Dept. SCM > Algol68 R (ICL 1906S) - now defunct as of 1984 > Algol68 S (Modular One) - '' ditto '' > Algol68 RS (VAX/VMS) - defunct as of 1988 - > moved to Irvine ADA on HP 850 and 300 series. > FLACC Algol68 (VM/CMS) still in use as a teaching language until > next year. > > However, a better test of the language as a piece of design is the number > > > of key concepts it introduced. This includes > > formal definition of static semantics using a van-Wingaarden grammar Once again, we are using different criteria for success. You are talking about abstract, ideal success; I am talking about producing a usable tool that would be widely adopted. Consider the following criteria for success: If Algol-68 had been a success, it would be used on more than 1/10 percent of the computers in the world. If Algol-68 had been a success, it would be used in every developed nation, not just a few nations (I am defining "developed nation" as one with an entry in the uucp map files :-) ). If Algol-68 had been a success, there would be Algol-78 and Algol-88, and they would be evolutionary enhancements of Algol-68, not major overhauls. If Algol-68 had been a success, Bjarne Stroustrup would have written "Algol with classes" :-). If Algol-68 had been a success, many programs selling 10,000 to 1,000,000 copies and written in Algol-68 would be on the market. If Algol-68 had been a success, Borland would sell Turbo Algol. If Algol-68 had been a success, Wirth would not have invented Pascal and Modula-2. If Algol-68 had been a success, UNIX would be written in it. Algol-68 fails every of these criteria for success, therefor it is a failure. QED. You may blame lazy compiler writers or the Evil Empire (IBM) for the failure of Algol-68, but I submit that the root problem was that the Algol-68 committee could not or would not produce a human-readable spec for the language. -- Bill Hutchison, DP Consultant rutgers!liberty!burdvax!ubbpc!wgh Unisys UNIX Portation Center "What one fool can do, another can!" P.O. Box 500, M.S. B121 Ancient Simian Proverb, quoted by Blue Bell, PA 19424 Sylvanus P. Thompson, in _Calculus Made Easy_
bga@raspail.UUCP (Bruce Albrecht) (11/29/88)
In article <406@ubbpc.UUCP>, wgh@ubbpc.UUCP (William G. Hutchison) writes: > [list showing that many "successful" languages are "better" if developed > by a small group ] > > I still maintain that this supports my earlier thesis: that committee- > designed languages fail and individually-designed languages succeed. Now that > I have defined success and failure more clearly, more people might agree. I have sometimes agreed with this thesis, but I really wonder if it's just another truism. There are a lot of languages out there that were developed by individuals (Snobol, Icon, Euclid, Trac, FP, etc.) that probably would be considered successes under your first criterion, but never achieved wide-scale popularity, for numerous reasons, including lack of publicity or machine implementations, or similarity to other languages. Sure, some of the individually designed languages are popular, and are "well-designed", but I don't buy that it is because of how many people designed it. I wonder if C would be popular today, if there hadn't been a university computing revolution around Unix, and I'm not convinced that Modula 2 would be any more successful than any other Pascal successor, if it had been designed by anybody other than Wirth. Did IBM become the number one computer company in the world because it built better machines and better software? I don't think so. The right kind of salesmanship did it, and I think that this is true of programming languages as well.
wgh@ubbpc.UUCP (William G. Hutchison) (11/30/88)
Thank the gods of Internet! I have finally elicited a rational response to my original posting! In article <79153@sun.uucp>, khb%chiba@Sun.COM (Keith Bierman - Sun Tactical Engineering) writes: > In article <406@ubbpc.UUCP> wgh@ubbpc.UUCP (William G. Hutchison) writes: > >Before we get embroiled in a meaningless argument, let me assert that there > >are at least two criteria for success of a programming language: > > success-1: having lots of neat design ideas, and > > success-2: being widely adopted. > text deleted > > I still maintain that this supports my earlier thesis: that committee- > >designed languages fail and individually-designed languages succeed. > I appreciate your clarification of success, but I think your thesis > remains unsupported. > > Here are some more opinions: > >Ada success-1? failure-2? small group (Ichbiah & Co.)? > too early to tell, but since commercial shops are chosing it for new > work (not yet in droves though) it may very well be a success-2. I > would have classified Ada as a committee Thanks for your input on Ada. I do not know how large Ichbiah's group was, so I did not know whether to call it a committee. > Using US success as criteria for failure-2 [of Algol-68] seems a bit parochial I respectively submit that I was not using US success as a criterion for the failure of Algol-68. I submit the lack of professional, commercial compilers for Algol-68 on UNIX or MS-DOS as evidence that Algol-68 failed worldwide. I quote MS-DOS and UNIX because they are emerging standard operating systems. Even if Manchester U had implemented Algol-68 on MUSS, I consider that community of users to be negligibly small. > >Pascal success-1 success-2 small group > success-1 ?? Nearly every single early implementation had to massively > extend it to make it useful. Code portability was nil, and etc. I consider Pascal to be a teaching and publication language, not a practical application language, so I consider it to be a success, *given Wirth's stated design goals*, not the goals who wanted Pascal to replace FORTRAN, COBOL, or PL/I. I disagree with a lot of Keith's other opinions, but he is rational and intelligent, so I will not quibble with them. (no point in duplicating them here). -- Bill Hutchison, DP Consultant rutgers!liberty!burdvax!ubbpc!wgh Unisys UNIX Portation Center "What one fool can do, another can!" P.O. Box 500, M.S. B121 Ancient Simian Proverb, quoted by Blue Bell, PA 19424 Sylvanus P. Thompson, in _Calculus Made Easy_
steve@ragman (Steve Stevenson) (11/30/88)
From article <406@ubbpc.UUCP>, by wgh@ubbpc.UUCP (William G. Hutchison): > > Ada success-1? failure-2? small group (Ichbiah & Co.)? > Algol-60 success-1 failure-2 small group > Algol-68 success-1?? failure-2 committee > C success-1 success-2 small group > COBOL failure-1 success-2 committee > FORTRAN failure-1 success-2 small group > FORTH failure-1 success-2? small group > LISP success-1 failure-2(this is changing) small group > Modula2 success-1 success-2 small group > Pascal success-1 success-2 small group > PL/I failure-1 failure-2 large committee Though your table seems to be correct as far as languages now in use is concerned, I think you should look at another perspective. The impact of Algol-60 on the follow designs is considerable. The fact that call by name is still considered a valid question on the advanced CS part of the GRE is some evidence. There are notable absences on the list: Simula-67 for example. Simula is the ancestor of Ada and Modula. Likewise, CPL and BCPL. Languages are often busts because their inventors try to pass them off as the UNIQUE solution to ALL the world's problems. C, when if first came out, me with tremendous resistance. It's still would not be my choice to write a check writing program. Pragmatic issues will win out. Steve (really "D. E.") Stevenson steve@hubcap.clemson.edu Department of Computer Science, (803)656-5880.mabell Clemson University, Clemson, SC 29634-1906
ok@quintus.uucp (Richard A. O'Keefe) (11/30/88)
In article <408@ubbpc.UUCP> wgh@ubbpc.UUCP (William G. Hutchison) writes: > If Algol-68 had been a success, it would be used on more than 1/10 percent of >the computers in the world. Gee, I guess that means C is a failure. > If Algol-68 had been a success, it would be used in every developed nation, >not just a few nations (I am defining "developed nation" as one with an entry >in the uucp map files :-) ). By that criterion, I suppose we must reckon 80*86 assembler as one of the most spectacularly successful languages ever. > If Algol-68 had been a success, there would be Algol-78 and Algol-88, and they >would be evolutionary enhancements of Algol-68, not major overhauls. Be careful when you bring evolution into things: remember that the dinosaurs were **superior** to the mammals. We are still waiting for a language which is as good as Algol 68. > If Algol-68 had been a success, Bjarne Stroustrup would have written >"Algol with classes" :-). Algol with classes already exists: it is called Simula 67. In fact, that is where the word "class" comes from. (Simula-67 had *type-safe* separate compilation, something C++ still lacks.) > If Algol-68 had been a success, Wirth would not have invented Pascal and >Modula-2. Let's see "if Pascal had been a success, Wirth would not have invented Modula and Modula 2 ..." Hmm, something wrong with that (:-). > If Algol-68 had been a success, UNIX would be written in it. Why? FORTRAN was a success. Does it follow that "If FORTRAN had been a success, UNIX would be written in it"? (PR1MOS was!) > Algol-68 fails every of these criteria for success. Set up a straw man, and surprise! you can knock him down. > You may blame lazy compiler writers or the Evil Empire (IBM) for the failure >of Algol-68, but I submit that the root problem was that the Algol-68 committee >could not or would not produce a human-readable spec for the language. Have you ever tried to read the formal definition of PL/I? How about the INRIA formal specification of ADA? Nope, the trouble was that the Algol 68 committee were painfully aware of the trouble spots that had been left in Algol 60 by an informal specification, and tried to make a formal specification, but people went on preferring informal specifications, loopholes and all. (Witness the apalling confusion about Pascal I/O, and the fact that ">" in Common Lisp is not transitive.) *Other* people soon produced easy-to-read descriptions of the language.
chl@r1.uucp (Charles Lindsey) (11/30/88)
In article <406@ubbpc.UUCP> wgh@ubbpc.UUCP (William G. Hutchison) writes: > success-1: having lots of neat design ideas, and > success-2: being widely adopted. > > Here are some more opinions: > ... >Modula2 success-1 success-2 small group >Pascal success-1 success-2 small group No. Bill Hutchison still does not understand. He now categorises ALGOL 68 correctly, but for the Wirth offerings he should have written Pascal failure-1 success-2 one man Modula2 disaster-1 success-2 one man In both of these cases the problem was that the one man did not have the slightest idea how to write a consistent and leak-proof Language Defining Document. As a result, both langauges leak (the second one more so). It took years of effort by an ISO committee to patch up the PASCAL mess (and the result is indeed a camel, but that is not the committee's fault). Another committee is currently trying to do the same for Modula-2. BTW, I see that DEC have now produced a Modula-3 (Luca Cardelli et al, Digital Systems Research Center, Palo Alto, August 1988), but I have not had time to read it yet. Charles Lindsey chl@ux.cs.man.ac.uk
anw@nott-cs.UUCP (11/30/88)
In article <409@ubbpc.UUCP> wgh@ubbpc.UUCP (William G. Hutchison) writes: > Even if Manchester U had implemented Algol-68 on MUSS, I consider that > community of users to be negligibly small. One of the biggest in the UK. But I suppose WGH considers the whole of the UK, nay Europe, negligible. :-) -- Andy Walker, Maths Dept., Nott'm Univ., UK. anw@maths.nott.ac.uk
anw@nott-cs.UUCP (12/01/88)
In article <408@ubbpc.UUCP> wgh@ubbpc.UUCP (William G. Hutchison) writes: > >Consider the following criteria for success: > > If Algol-68 had been a success, it would be used on more than 1/10 percent of >the computers in the world. By this criterion, Cobol certainly fails, Fortran probably fails. Oh, you meant *real* computers? > If Algol-68 had been a success, it would be used in every developed nation, It's been *seriously* used, to my knowledge, in the USA, Canada, UK, France, Germany, Czechoslovakia, USSR, Netherlands, Belgium, and a few others. Don't know of any use in Luxembourg. Where else were you thinking of? > If Algol-68 had been a success, Wirth would not have invented Pascal and >Modula-2. Wirth is a law unto himself. If P had been a success, he presumably shouldn't have invented M2. If M2 had been a success, he wouldn't have invented Oberon. If Wirth had understood A68, the world might have been different in many ways. > If Algol-68 had been a success, [ a few more silly ones ] > > Algol-68 fails every of these criteria for success, therefor it is a failure. > QED. Whether or not the conclusion is true, it "therefor" doesn't follow from this argument. > You may blame lazy compiler writers or the Evil Empire (IBM) for the failure >of Algol-68, but I submit that the root problem was that the Algol-68 committee >could not or would not produce a human-readable spec for the language. But this is ridiculous. (a) The A68 spec (the Revised Report, I assume you mean) is perfectly readable, and has been read and understood by many, many people. Anyone capable of writing a compiler for any language whatsoever should have no problems with the RR. (b) Many other languages have specs of equal or greater difficulty, or (worse) no spec at all. I haven't seen the new C standard, but if it is *significantly* "easier" than the RR, the committee simply won't have done its job. (c) Users learn from textbooks, not from "specs". (d) The A68 group *did* commission a user-friendly description (Lindsey & vd Meulen: "Informal Introduction to Algol 68", already mentioned several times in this group). -- Andy Walker, Maths Dept., Nott'm Univ., UK. anw@maths.nott.ac.uk
pds@quintus.uucp (Peter Schachte) (12/01/88)
C'mon, people, this argument isn't getting anywyere. anw@maths.nott.ac.uk (Dr A. N. Walker) argues that much more than two institutions have adopted Algol-68, and there are several good compliers. But would you go so far as to say that Algol-68 has caught on? I hope not. wgh@ubbpc.UUCP (William G. Hutchison) argues that the fact that Algol-68 usage is not widespread means that the langauge is a failure, implying, I take it, that it isn't a good language. But as has been pointed out earlier in this thread, a language's popularity is often determined by political (or random) factors, not its elegance or performance (how widely used is Miranda? BLISS?). I don't know Algol-68, but I've heard very few negative comments about it from people who do. It's pretty silly to tear it down based on how widely used it is. How many people really think the most widely used languages (COBOL, FORTRAN, and assembler) are the best? If wgh@ubbpc.UUCP is just arguing that languages that ultimately catch on are those that are designed by an individual rather than a committee, I'm still skeptical. COBOL, if I remember correctly, was a committee effort. I believe FORTRAN was designed by a fairly small group, not an individual. I have no idea how many people designed the first assemblers. -Peter Schachte pds@quintus.uucp ..!sun!quintus!pds
jejones@mcrware.UUCP (James Jones) (12/04/88)
I think that a comment on language specifications that was made in SIGPLAN
Notices some years back is appropriate here. Pascal and C appear to be
following similar paths as far as specifications go: initially there is
a short specification, full of holes. Then, as people realize the pitfalls,
new standards come out that at least make the holes harder to find,
that are far longer, and that attempt to use the blunt instrument of natural
language prose to specify precisely. (Can anyone look at the X3J11 prose
concerning "top type" and say that they know what is meant? Should
printf("%05d", -3) print "-0003" or "000-3"?)
I wonder if someone who was around when the Algol 60 Report first came out
(and wasn't playing with blocks like I was at the time :-) would comment
on the initial popular reception of BNF; I suspect that it may well have
been similar to that which greeted van Wijngaarden grammars. There are
texts that make v-W grammars understandable (McGettrick, and Cleaveland
and Uzgalis are the ones I know of); the technique of blind-alley
productions is straightforward. I don't argue that Algol 68 is perfect,
but rather that it is far better specified than most other programming
languages.
James Jones