Re: Add nested-function support in a language the based on a stack-machine

Martin Ward <martin@gkc.org.uk> writes:
>Of course, with hindsight we can see that defining function parameters
>directly in the language would be an even better solution:
>but language design was still in its early days at the time,
>and Algol 60 was "not only an improvement on its predecessors,
>but also on nearly all its successors" (C.A.R. Hoare).
>
>How many modern languages can claim the same?


Was Hoare right in making this claim? He made this claim in 1973, and
indeed most langauges developed between 1960 and 1973 have been
forgotten by now, and probably Algol 60 was an improvement over many
of them.


Interestingly, Hoare was in the more implementation-oriented Algol W
faction of the post-60 Algol committee rather than the more
mathematical faction that won out and eventually produced the Algol 68
report. He probably meant especially Algol 68 as successor over which
Algol 60 was an improvement. So this claim actually condemns the
attitude that you praise.


[Anton Ertl:]
>> Algol 60 did not have first-order functions and closures. It did have
>> lexical scoping, though, which the Lisp family only acquired with
>> Scheme in 1975.
>>
>> Algol 60 certainly did not have abstract data types. It did not even
>> have records.
>>
>> So these are examples that actually contradict your theory.
>
>My theory is that the attitude of the Algol 60 designers towards
>language design is what led to these innovations appearing
>over then next 20 years: this is the "explosion of productive
>research and development in compilers and language implementation"
>that I was referring to.


Higher-order functions (I somehow mixed up "higher-order" with
"first-class" in the above) were already available in IPL, before
Algol 60, which falsifies this theory for this feature.


Records were available in Cobol, contemporary with Algol 60, so again,
this theory is falsified in this case.


Concerning features that appeared after 1960, there is no way to
verify or falsify your theory.


>What similar innovations in compilers and language design
>have appeared over the *last* 20 years? (Haskell is still considered
>by some to be a scary new innovative language: it was initially
>developed in the early 1990's, over 20 years ago).


Many people that used to research programming in the 1960s thought in
the late 1960s that programming languages were a solved problem, and
refocused on software engineering. The field certainly has matured,
and a sign of that maturity is that 1) you don't get great
breakthroughs all the time and 2) that even when there is a useful
innovation, it takes quite a while until it appears in mainstream
languages.


Actually, it even took quite a while in the early years; e.g., IPL
(1956) had higher-order functions, Algol 60 didn't, Pascal (1970) did,
Ada-83 didn't (IIRC).


And a lot of the work that has been done in the last decades are about
making various features fit together that have lived in separation in
various programming languages for a long time. E.g., Java 5 (2004)
added generics to Java and Java 8 (2014) added lambdas. Both feature
are much older, but needed to be integrated with the Java type system.
And of course, people also needed to be convinced that these features
are worth the complexity that they add to the language.


There are new features being developed all the time. We will see
which of them make it into a mainstream language, but in any case that
will take it's time.


One of the more prominent recent ones is the way that Rust combines
static type checking with explicit memory management to ensure memory
safety in low-level languages.


There is also quite a bit of innovation in tools, e.g., in fuzz
testing, and in using theorem provers for software verification.


- anton
--
M. Anton Ertl
anton@mips.complang.tuwien.ac.at
http://www.complang.tuwien.ac.at/anton/

Return to the comp.compilers page.
Search the comp.compilers archives again.