Languages Pre-Fortran | Hacker News Reader

Languages Pre-Fortran

craftofcoding.wordpress.com

71 pointsBostonian24 comments

One feature, as far as I can tell, that no languages had until Algol-60 was recursion (https://craftofcoding.wordpress.com/2020/12/01/recursion-the...).

It's hard to imagine nowadays how controversial this was. Previous versions of Algol did not necessarily require any form of dynamic memory allocation. Recursion requires it in some form to avoid overwriting a procedure's variables upon the recursive call.

Languages that forbid recursion (like Fortran before F90) can allocate for peak memory usage before runtime, which is especially useful on RAM-poor computers.

EDIT: The site also has a great quote on the subject (https://craftofcoding.wordpress.com/2022/10/20/d%c8%b3kstra-...).

Of course Lisp had recursion before Algol60.

Lisp was in fact returning up from 19 levels of recursion, when it encountered Algol that was just starting on its way down. Lisp thumbed its nose:

"I got there first, Algol; don't bother looking for the return value!"

Indeed, Lisp contributed to why Algol 60 has recursion. Quoting https://vanemden.wordpress.com/2014/06/18/how-recursion-got-...

> McCarthy, fresh from the success of his Lisp project, was enthusiastic about recursion as an elegant way to get computers to do what they are best at: repeat execution of the same code with suitable modification each time around. In fact, the first Lisp had no iteration, so that the only way to add all elements of a linear list was to write a recursively defined function. As a member of the Algol committee he proposed making the possibility of recursion a feature of the new language. The proposal was crowded out by more pressing concerns. The result was that in the early months of 1960, when the report was to be finalized, there was no consensus on recursion.

Ah, of course I forgot lisp. Came so early, considering what it could do.

When you have a single fixed activation record per routine you also lose reentrance, not just recursion. Which means any tasking system has to be designed around that as well. A low priority task in the middle of a call cannot be suspended if a higher priority task needs to make use of the same subroutine, as an example. So all tasks have to run to completion or to some known safe points.

> Recursion requires [dynamic memory allocation] in some form to avoid overwriting a procedure's variables upon the recursive call.

Technically untrue, actually; you can require any potentially-recursive procedure to take a (pointer to a) array of stack frames to use when making a recursive call. However I don't know of any programming languages that actually do that, rather than supporting stack frames implicitly or (historically) prohibiting recursion altogether.

Having an explicit stack as part of the algorithm is not usually counted as recursion, as far as I know.

I never cease to be amazed by the fact that Algol-60 was standardized in the form that it was. It's not just that there were many innovations there - it's the complexity of implementation. Recursion (at the time) was one of the sticking points, but there were far bigger ones!

Consider, rather, the fact that Algol-60 had nested functions which captured the enclosing environment and could also be passed as arguments to other functions. Or call-by-name, whereby expression used as an argument in a function call would be re-evaluated every time it's referenced inside the function - again, kinda like closure, except this one could also be used on the left side of assignment. Or the ability to pass labels as function arguments, which could then be used for nonlocal goto across multiple function boundaries.

And now try to implement all this in a compiler targeting a machine with memory measured in kilobytes. Oh, and the compiler itself also runs on another such machine.

For the curious, here's the language specification: https://www.masswerk.at/algol60/report.htm

And then comes a group of folks and throws most of Algol achievements in safety, by creating an OS with a systems language where everything goes.

"The more I ponder the principles of language design, and the techniques that put them into practice, the more is my amazement at and admiration of ALGOL 60. Here is a language so far ahead of its time that it was not only an improvement on its predecessors but also on nearly all its successors."

- C.A.R. Hoare in 1974 in "Hints on programming language design"

https://www.cs.yale.edu/flint/cs428/doc/HintsPL.pdf

I would actually disagree with that - call-by-name is very much an anti-feature, for example, as are goto-labels-as-function-arguments. And, at the same time, crucial features such as pointers were missing.

OTOH Algol 68 is a whole different story, and for all its weirdness (much of which is terminological - "transput" for I/O, "mode" for type etc), its extreme orthogonality and consistency is very elegant.

Do I remember correctly, that the stack variables were controversial even when developing C, and the compromise was that it supported both with `static` and `auto` keywords, and the controversy moved to what is the default, which was sneakily set to `auto`.

> 1948 – Composition (Curry)

It took me a minute to realize that it wasn't saying that the language supported currying, but was made by curry.

I know intellectually that curry was a famous person but kind of wild to see it like this.

well Curry could have developed Currying in Composition, so you could still be right.

> Fortran I (1957) included comments

That's neat - I guess by this time Fortran programs were getting big/long enough that comments were needed.

According to every history I've ever read (most notably, Backus's talk at the first History of Programming Languages) conference, Fortran was not released outside of IBM before this 1957 release, and there wasn't a compiler debugged enough to use much before that. (This blog post is the first I've ever heard of "Fortran 0".) https://dl.acm.org/doi/pdf/10.1145/800025.1198345

Not exactly. At this time programs were written on punch cards. The FORTRAN ‘comment’ was just a way to get the compiler to ignore the punch card. Comments existed long before, such as notes written or typed directly onto the card.

Ah of course - when I saw comment I got tunnel vision and completely forgot that it wasn't text on screens.

1946 – Flow Diagrams: As a graphical programming language, they've been implemented at least twice: GRAIL (GRAphical Input Language) in 1969, and DRAKON in 1996.

IPL, a precursor of Lisp, was implemented in 1956.

Are there any usable implementations of these languages anywhere?

It would be interesting to see what 'obvious' things weren't so obvious. What weird things seemed sensible at the time, etc

> 1954 – ПП-2 (Kamynin/Liubimskii)

> 1955 – ПП (Ershov)

What was going on here?

For some reason they don't mention ukrainian https://en.wikipedia.org/wiki/Address_programming_language which, according to some sources, was used to program soviet ballistic missiles.

In Russian sources that I can find, it goes like this:

1954 - ПП-1 (prototype / proof of concept)

1955 - ПП-2 (for Strela-1)

1955 - ПП БЭСМ (for BESM)

Followed by more versions for various new mainframes that appeared, named by suffixing "ПП" with the name of the hardware - e.g. there were distinct versions of ПП for Strela-3, Strela-4, and Strela-7.

The abbreviation itself stands for "программирующая программа", "a program that programs". So it sounds like it was originally a name of the specific prototype, but then became a generic term for any kind of compiler for a short while (later replaced by "translator", probably under the influence of FORTRAN and ALGOL).

Reply on news.ycombinator.com