The Algol 68 Genie project | Hacker News Reader

The Algol 68 Genie project

jmvdveer.home.xs4all.nl

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.

> The lack of a concrete syntax also harmed it: different implementations spelled the “begin” keyword as BEGIN, 'BEGIN, and .BEGIN. Goodbye portability!

It's not all downsides, though. Due to Algol (both 60 and 68) treating keywords as abstract symbols, it made it possible to translate those keywords to other languages. This was done in USSR, for example, and made Algol much more accessible to programmers there.

(I know there were similar experiments elsewhere in Europe; not sure if they were quite as successful, though.)

Yes, in my youth I used Grenoble ALGOL 60, in which one said 'DEBUT'...'FIN' around a block. There was also something called Socialist ALGOL 60, which was apparently used widely in eastern bloc countries.

Soviets had quite a few different ALGOL 60 and 68 dialects, but I don't recall seeing anything resembling that name when digging through the history of it. It sounds more like an informal name of some dialect, or perhaps all the Eastern Bloc dialects collectively?

BTW the ability to translate the language had some other interesting consequences; apparently, they found that ALGOL 68 was sufficiently expressive to design what we would now refer to as DSLs, for applications varying from CNC to accounting. The end users of those languages would be even less likely to know English, of course.

To be honest, I don't recall when I was told about Socialist ALGOL; to the best of my knowledge, it was somebody at one of the ALGOL 68 workshops that were held back then, but I can't recall who. And I suspect that the official name of this dialect would not have been “Socialist ALGOL” anyway. The idea was that it would unify all the ALGOL 60 dialects in use around the east bloc. (And yes, I'm familiar with the saying that if you replace n ways of doing the same thing with one, you end up with n+1 ways of doing the same thing.)

I'm sure you remember that at the time it was written people were still trying to figure out what a computer language should look like - also most people at the time only had upper case (card punches)

The whole how do we use keywords in compilers (and in multiple languages)? how do we represent types? was all still something people were thinking through - in retrospect the two cases thing for parts of the language was a mistake, as was the 2 level grammar spec

There were literally hundreds of languages around when the ALGOL 68 effort started, so there was lots of experience to draw from.

Both the lack of concrete syntax and the 2-level grammars were disputed at the time, and one might remember that Wirth and Hoare designed ALGOL W as a reaction against the ALGOL 68 effort. (I liked both languages, silly me.)

My original comment was not intend as snark against the ALGOL 68 designers, but rather to point out that the language had a lot going for it, even with these serious flaws. But as is often the case, we learn more from mistakes than successes.

When I was reading the ALGOL working group archives, the impression that I got was that Wirth and Hoare designed (what would later be called) ALGOL W as a candidate proposal for ALGOL X, the latter being what would eventually evolve into ALGOL 68.

A number of eminences in the ALGOL 60 world strongly resisted the philosophy behind ALGOL 68, and spoke up vehemently against the direction that the language was going in. Wirth and Hoare were indeed developing ALGOL X (W comes before X), while what is now ALGOL 68 was ALGOL Y. The X supporters vehemently opposed the direction in which Y was going, and many of them, including Wirth and Hoare, disassociated themselves from the whole enterprise. At that point, the X project was essentially dead (though it's possible to consider Pascal as its immediate successor).

By the way, I want to praise C. H. Lindsey, whose “Informal Introduction to ALGOL 68” rescued the language from indecipherability and showed that there was a useful language lurking inside.

A lot of this history is lost now. I heard bits and pieces of it in my time on the periphery of the UBC ALGOL 68 project circa 1970-5. The Wikipedia articles on ALGOL W and 68 also hint at it.

Much has been saved, too, although finding it is not always easy. FWIW most of my research was based on the stuff here, but mostly focused on ALGOL 60:

https://archive.computerhistory.org/resources/text/algol/alg...

Algol 68 was the first programming language that was being taught at the University of Twente when I started studying there in 1981.

I vaguely remember something about a compiler (probably the Algol 68 compiler) with the wierdest bug that I have ever heard about a compiler: In certain months of the year, it had problems with compiling certain programs and students were adviced to try again a month later. The bug was never found.

I can imagine this scenario happening in Algol68 (or indeed any language), especially in the 1970s when memory was shared, unprotected and at a premium.

The scenario could have been a season batch job that corrupted some required shared memory.

But, Algol68 included four main aims and principles of design: Including Security: "Algol 68 has been designed in such a way that most syntactical and many other errors can be detected easily before they lead to calamitous results. Furthermore, the opportunities for making such errors are greatly restricted."

On the other hand, I did speak to an ICL engineer once, and he told a story of an ambitious ICL programmer adding a "Happy New Year" console to the Geroge OS (Written in Assembly language)

The ambitious ICL programmer decided it was too tough to test this one-off hack, and rolled out the OS update with his happy hack, untested.

The update seemed to run fine for a few months... Until months later (at New Year as it happens) all the ICL servers in New Zealand crashed, and two hours later all the ICL servers in East Coast Australia crashed. This triggered a frantic call from the NZ ICL engineer to ICL in London England warning them of the impending doom in the UTC zone.

Yay... but this ICL Happy NY hack was probably written in ICL assembler.

On the other hand there was a nice little hack used by ICL in Algol68R that could be used today sniff out NULL pointer issues: https://en.wikipedia.org/wiki/ALGOL_68-R#F00L

Past submissions:

https://news.ycombinator.com/item?id=31283119 (14 comments)

https://news.ycombinator.com/item?id=18734687 (0 comments)

https://news.ycombinator.com/item?id=5268301 (0 comments)

Algol 68 was/is a magnificent language, and the experience of reading the Revised Report from cover to cover is unforgettable.

The logical structure of the language was driven to the extreme: I vaguely remember that

  int a;

was merely an abbreviation of something like

  ref int a = new int;

"INT a" would just declare a local immutable binding of type integer.

"LOC INT a" would be syntactic sugar for "REF INT a = LOC INT", which would be something akin to "int *a = alloca(sizeof(int))".

>"The Algol 68 Genie project preserves and promotes Algol 68 out of educational as well as scientific-historical interest, by making available a recent checkout compiler-interpreter written from scratch by Marcel van der Veer, together with extensive documentation for both the language and this new implementation."

Can someone say what a "checkout compiler-interpreter" is? I am not familiar with this term. Is this something specific to Algo 68?

Url changed from https://jmvdveer.home.xs4all.nl/en.download.algol-68-genie-c..., which points to this.

Reply on news.ycombinator.com