Ok, you caught us. It certainly isn’t going to be the year of Algol. When you think of “old” programming languages, you usually think of FORTRAN and COBOL. You should also think of LISP. But only a few people will come up with Algol. While not a household name, it was highly influential, and now, GCC is on the verge of supporting it just like it supports other languages besides C and C++ these days.
Why bring an old language up to the forefront? We don’t know, but we still find it interesting. We doubt there’s a bunch of Algol code waiting to be ported, but you never know.
Algol first appeared in 1958 and was the lingua franca of academic computer discussions for decades. It was made to “fix” the problems with Fortran, and its influence is still felt today.
For example, Algol was the origin of “blocks of code,” which Algol set between begin/end pairs. The second version of Algol was where Backus-Naur form, or BNF, originated, something still of interest to language designers today.
Interestingly, the new compiler will do Algol 68, which was the final and not terribly popular version. It was sort of the “New Coke” of early computer languages, with many people asserting that Algol 60 was the last “real Algol.” Algol was known for sometimes using funny characters like ≡ and ⊂, but, like APL, had to adapt to more conventional character sets. Most of the Algol specifications didn’t define I/O, either, so it wasn’t enough to know Algol. You had to know which Algol so you could understand how the I/O worked.
If you want to learn Algol, there’s a tutorial on GitHub (use the compiler online, if you like). While [Niklaus Wirth] didn’t create Algol, he was a major player in some of its later development.
My first job at General Motors involved a CAD system called GDSII. It stood for Graphic Design System 2, originally created by GE.
It ran on a Data General S-280 Eclipse, with 1M of RAM. Yet it supported four workstations and a terminal for admin purpose, while remaining fairly responsive. What they could do with such low resources back in the day!
I remember one of the support people telling me the system was coded in ALGOL.
The extension language was calle GPL, or Graphical Programming Language. I’ve never used APL, but I was told that GPL was at least similar, especially with regard to array/matrix handling.
That sort of ties the languages mentioned above, ALGOl and APL together.
I remember the system fondly.
Algol is one of those obscure languages that has been in decline for over 30 years. (Over 40 years?) Apparently there is still some “historical interest” in it, but I assume there are good reasons for the decline. Why such a language is added to GCC is beyond me. Apparently there are CLANG versions for both AVR’s and Cortex-M. It seems to be a pretty mature compiler, but I don’t like the links to the fruit brand PC’s.
why add a language to GCC? presumably because someone could, and thought it’d make a fun project — perhaps to teach themselves more about GCC or just compilers in general.
after all, Modula-2’s in there. i can’t think of why else that’d be the case, either — who uses Modula-2? there’s (probably?) more practical use for the Ada compiler that’s also in GCC.
If the language isn’t constantly being mangled according to the kitchen sink approach so popular among modern language committees, then writing a front-end for it isn’t really a big task. That’s the magic of how projects like GCC and LLVM are structured…you just write the front-end and feed into a common optimizer and code generator step. That was a founding goal of LLVM and something GCC has made incremental steps towards over the decades.
So it becomes one of those “why not?” sort of things.
I remember Algol was a major language in Burroughs mainframes that ran the MCP operating system (B-6000/7000 specially), and there were a variety of dialects available, plain Algol for normal programming and DC Algol for systems programming among them.
DC Algol specially gave you quite a bit of control, enough to crash the entire system even from a common non-admin user account (don’t ask me how I know…)
I programmed a bit in Algol from 1983 to 1987 during my Engineering graduation, in a B6900. I have precious little memory of it other than it was somewhat similar to Pascal and very easy to learn. Can’t remember which dialect it was, though, 60 or 68.
Algol was famously and accurately described as an improvement on most of its successors.
Due to the limitations of compiler and computer technology, there were many variants each with a slightly different subset and purpose. That wasn’t particularly important at the time, since the concept of “porting code” was not high on the list of most peoples’ priorities.
There is a decent case to be made that while Algol-60 deserves to be remembered as one of the triumvirate of languages (Algol, FORTRAN, COBOL), it was also an early example of the “second system effect”.
Overall Algol has been as influential as another of its contemporaries, LISP.
Ah, if I only had kept those 2000+ punched cards with my symbolic math interpreter from uni! It could differentiate and integrate expressions, simplify the results and use it for subsequent calculations. Written in ALGOL W and ran on the university’s IBM S/370 165 mainframe with, if I remember correctly, 1.5MB of memory and a scorching clock speed of 17MHz. 🤯
Whew! 🫨
My Electronics degree at Southampton University in England began in 1974, with an allocation of some 15 seconds of CPU time a week on the ICL mainframe belonging to the Maths department. The Electronics Department thought they would try to get students interested in these new-fangled computer things, even though their focus was on triple integrals, electrons and holes, and understanding Maxwell’s equations.
I quickly found that running BASIC chewed that time allocation in very short order, so I chatted to the operators at the computer centre. They said I could try the Algol compiler instead.
So, I found a book in the Uni bookshop on Algol 60 as implemented on the ICL 1907, found out in which room the IBM 029 punch card machines were set up, and started programming.
Running a job entailed punching a small deck of cards, taking them to the cafeteria-style desk, where they’d accept them. Maybe half a day later, the job output, wrapped around the deck of cards would turn up in a pigeon hole.
After getting over the usual problems that plague a new language, and every job output comprising one sheet saying ’30 cards read’ with a brief syntax error on card 2, I became somewhat proficient. The operators even gave my account more CPU time per week, so I could get more elaborate. Punching conventions made it a bit of a pain to write on an upper case only punch card –
‘BEGIN’
‘INTEGER PROCEDURE’ FACTORIAL(N) ;
‘VALUE’ N;
‘IF’ N ‘LE’ 1 ‘THEN’ …
but those were the limitations of the technology available to me – like having to use batch processing and punch cards.
However, Algol introduced me to structured programming and formal definitions at a time when I might have just written some shockingly bad BASIC code instead. Those good habits help set me up for a career in computing. (Shame I was doing an electronics degree)
I started in ’75, having used (and liked) Tony Hoare’s Algol60 compiler while at school.
I looked at Algol on the ICL29XX, rapidly decided I would never get all the punctuation correct, and decided to do Other Things.
What could you have run on the Honeywell DDP in the Zepler building’s basement? I only used it for 6800 assembler, but the grad students were doing LU factorisation and similar. Probably Fortran, but I don’t know.
IIRC the PDP11 in the maths department could only run Basic – and was thoroughly “owned” by electronic engineering students.
IIRC the maths department had accepted the new ICL29XX reluctantly; ICL made an offer that couldn’t be refused so it would be exposed to a “hostile” university environment before being released commercially.
Algol68C was one of the main teaching language at Cambridge. It was used to write the first capability based operating systems on the CAP computer. I found it excellent for making you think about the problem being solved. Often i found that when the code compiled, it worked
I started my physics degree at Queen Mary College (U of London) in 1973, the introductory CS course taught us all Algol 68 (using the RSRE 1900 A68 compiler) as the common language that everyone doing CS courses would then use for their coursework.
Submission was similar to that described above at Southampton.
I ended up with joint Physics/CS – it turned out that my maths wasn’t good enough to solve partial differential equations needed for quantum mechanics, I also worked out that CS paid a lot more than High Energy Particle Physics research 🤣
Of course I no longer have