Hacker News Reader

Comment by glimshe | Hacker News Reader

One cool thing about Algol is that, while the language itself is over 60 years old, most modern programmers can have a decent understanding of source code written in it. It's a bit like reading 17th century English. You don't quite understand everything, but you can grasp most of it.

I wonder why the retrocomputing crowd hasn't done much in ALGOL. Perhaps because it's just easier to write in BASIC, which was influenced by it.

View on HN

Assuming we're talking about Algol 60, it really depends on what kind of source code. When you look at the more creative applications of call-by-name, for example, it looks utterly alien. Or stuff like label arguments and switches.

OTOH if you disregard those, the rest is simple to understand because there isn't much of it. E.g. there's a grand total of three types: integer, real, and Boolean. There are no structs, pointers, or really any derived types (it has arrays, but they aren't technically types but rather an orthogonal property of variables).

But, for the same reason, it's not particularly useful. The lack of pointers especially limits what you can do with it, even if you use it for its original primary purpose (reference implementations of algorithms).

Probably because of the mix with nostalgia, and the folks that would be nostalgic about Algol 60 hardly care about computers nowadays.

When I was a kid, the systems that we cared about were 8 bit home systems, starting with anything CP/M, and then there was the whole big machines being used at universities and our parents jobs, which we only knew from computer magazines.

Spaniard here; Spanish is like Lisp. Reading 17th century Spanish is almost a no brainer minus some Medieval knights' jargon (put from Cervantes on purpose on making fun on old-farts) and some 17th jargon too, specially from popular sayings just said in La Mancha region which are still in use because they are related to daily farm/fields/food but the rest of Spain has no clear references off.

Also the RAE institution for the Spanish Language does something similar to SRFI's + RSR?s for Scheme.

(Eleventh-century English is ... suprisingly approachable with the right textboox: https://ancientlanguage.com/vergil-press/osweald-bera/ https://youtu.be/YwECgGWCwis?t=508 .)

IIRC Algol was already dead and buried in the 80's, it certainly wasn't relevant or even available on most computer systems an 80's teenager had access to. The most popular high level language on 8-bit home computers was certainly BASIC, for compiled languages probably some dialect of PASCAL, and maybe FORTH for something entirely different.

BASIC didn't have to be a bad choice either, Acorn/BBC BASIC even had proper inline assembly.

It was pretty much dead by the mid-70s. PASCAL, C, FORTRAN, and COBOL killed it on mainframes + minis and it was too complex for micros. (Thus - BASIC.)

The twitching corpse lived on in the form of JOVIAL for DOD work (until ADA happened), and CORAL persisted in the UK because of bureaucratic momentum. Simula was another derivative that lasted for a while.

But C and PASCAL were better, simpler, equally productive languages. As soon as they appeared ALGOL 60 didn't really need to exist any more. And ALGOL 68 was an ALGOL too far.

Lest we forget, Pascal itself was an evolution of Algol-W, which was basically Algol with pointers and records. So in that sense, Pascal and the entire family of languages that it spawned are all direct descendants.

Algol 68 doesn't really have anything in common with Algol 60 apart from name. The syntax is completely different, as is the overall feel of the language.

W being Wirth.

Interesting - I remember working with someone that told me that they'd seen an ALGOL codebase finally get decommissioned in 2005 (the replacement system had run in parallel with it for a few years first) after first going live in 1979.

It surprised me because people talk about COBOL and Fortran being dead, but ALGOL always seemed really dead, and I couldn't believe that there was still ALGOL running this century.

I think ALGOL nowadays would likely work best as sort of a lingua franca psuedocode, I don’t think it would be too difficult to make that work. It kind of was already for a long time, as much of the Collected Algorithms of the ACM were originally written in it IIRC.

With a few exceptions (like APL), I've always found it pretty easy to read code in most languages, as long as I understood the paradigm, and the original author made at least a tiny effort to use sensible naming.

Imperative languages only have a handful of concepts, like variables, type declaration, looping, branching, function call, etc. and the language and the context generally make those pretty easy to identify.

The other language types (functional, forth-like, etc.) have similar (but often different) concepts, and once you understand the concept and can see it through the syntax, it's pretty easy to follow along.

Writing new code in a new language is the difficult part.

Reply on news.ycombinator.com