Looking back at ALGOL-68, it looks like comparatively small language compared to many of our current languages, e.g. Java, C++ and Python. I loved the definition of it, but never got to use it.
(Seriously, though - in retrospect, it feels like most of the complexity that the language was criticized for is standard fare in PLs of today, often in the same shape.)
That modern languages are even worse does not make ALGOL-68 good, in my opinion. It's understandable why people would like it, though, compared to modern languages.
This really does take me back, as I was a graduate student under J.E.L. Peck (though I didn't actually work on his compiler) back around 1970. I have always felt that ALGOL 68 (he insisted on the block caps) was undervalued as a programming language; it was harmed by its impenetrable specification (two-level grammars are a clever idea, but horrible for actual understanding), and the absolutist ideas of the compiler writers (the standard complaint about any short-cuts was “what if we have a left bracket, 50 pages of code, and the matching right bracket”, as though that was actually something somebody would do.
The lack of a concrete syntax also harmed it: different implementations spelled the “begin” keyword as BEGIN, 'BEGIN, and .BEGIN. Goodbye portability!
And finally, ALGOL 68 learned from ALGOL 60's failure to include an I/O library: they did a splendid job on their transput library. Unfortunately, it is record-oriented (as were most mainstream OS file systems of the time) at just the moment when Unix was about to popularize the byte-stream file abstraction.
I really wish that an ALGOL 68-style language had been successful, even given these mistakes (when you do a radical rethink of programming languages, you are bound to make mistakes). There was even at least one machine-oriented ALGOL-68 style language named Mary, which might have been a good replacement for C. It's good to see that at least some work on implementation continues.
I wouldn't be so dismissive of Algol 68. It wasn't particularly successful in production, but then neither was Algol 60. OTOH conceptually the former feels closer to modern PL design, with a greater emphasis on consistency and orthogonality. And if we're talking about specific features that ended up in other languages, well - the C keywords "void", "struct" and "union" all came from Algol 68.
While I don't speak Algol-68, I find the arguments interesting and enlightening... except for this bit: "state-of-the-art in programming languages hasn't moved much in those 41 years." While this is true to some extent, as mainstream dynamically typed languages pick up features from Lisp, I'd say that Haskell has a lot of new ideas. (I haven't yet figured out if those ideas help write better software, but that's more my failing than Haskell's.)
I said this on another forum recently. There were good reasons for rejecting ALGOL 68, both because of the language's complexity, and because of the incomprehensible 2-level grammars of the Report. (Disclaimer: my grad supervisor was one of the editors of the Report, and I did a small amount of ALGOL68-related work then.) Languages like Oberon exemplify simplicity; at a different abstraction level, so does Scheme. But the complexity battle has been lost: for example, C++ is arguably far more complex than ALGOL68.
Let me say this... there's a reason why ALGOL 68 is no longer used very much. At the time it was criticized for being horrendously complex, and there is some truth to this.
Notice that the email points out all the different things you can do with ALGOL 68 compared to Go. If we were to compare all programming languages this way, wouldn't C++ be the best language ever?
I'm not sure it's right about algol being dead, I've seen a renewed interest in it over the last couple of years, and I believe I even saw a new algol compiler - but I can't remember if it was for -68 or -60.
It didn't actually contribute much to the evolution of other languages though, right? Had anyone even heard of it when Fortran/ALGOL/etc were being designed?
Algol, and its formal EBNF description, is definitely the easiest language I have ever worked with. Burroughs, now Unisys, had an immensely powerful combination of true stack based hardware, a compact OS that supported parallel running across systems as well as programs, and various tailored flavours of Algol for comms, database and other use. A great development environment, decades ahead of its time. Alas C and Unix were cheaper and Burroughs never really understood that there was a market other than big tin users.
But yes, even now when I write Ruby or Python or Go, I miss the clarity of Algol.
Interestingly hardly anybody uses Algol, Smalltalk, Pascal and early Scheme anymore, while people still use Common Lisp. Perhaps "being small and beautiful" is actually a bad thing for a programming language?
Yeah for 'a dead language' there would only be ALGOL, PL/1, and not much else. Excluding really niche languages that never made it out the research lab in the first place.
Algol was huge - for the scope of its era, and the ancestor of many modern languages so its influence was outsize too. Where modern books that aren't language specific might express ideas and algorithms in C, most books used to use Algol. There was an entire generation of later languages that were called Algol-like: B, C, Pascal, Ada, Modula 2. Probably others.
Lazarus ( Free Pascal ) seems to be thriving actually. APL is probably as big as it ever was. COBOL will shrink over time but it may still outlast me. I have no insight into SmallTalk but my University curriculum included it and it would not surprise me at all to see it used academically today. I was also taught Scheme and Fortran and those are still going strong. If I wanted to use any of these, I know I can find both free and commercial dev environments easily that run on platforms I still use.
Is ALGOL still in use anywhere though? Is there a compiler available that runs on anything modern? I genuinely curious.
Algol 68 may have been a failure because it was ahead of its time, which meant it was hard to write a compiler for it. For example, Algol 68 had closures (apparently Knuth snuck them in).
reply