Re: language design after Algol 60, was Add nested-function support

Anton wrote:
> my counter-position papers are:
>
> http://www.complang.tuwien.ac.at/kps2015/proceedings/KPS_2015_submission_29.pdf
>
> http://www.kps2017.uni-jena.de/proceedings/kps2017_submission_5.pdf


Quote: "if the totally-defined C specified that shifting by the data
width produces 0, the compiler would have to implement shifts more
expensively on some machines; and if it specified that it produces the
unshifted value, it would have to implement shifts more expensively on
other machines."


This is a perfect example of support for my thesis. I am not happy
about this, since I was (and still am) hoping that my thesis would be
disproved :-(


To recap the thesis:


The Algol 60 designers placed mathematical simplicity (simplicity in
the language, ease of analysis etc) above the effort to implement the
compiler and execution efficiency of compiled code.


This attitude led to an explosion of productive research and
development in compilers and language implementation.


Since that time, language designers have become very cautious and
timid in specifying powerful new language features and compiler
research has stagnated (with C as an extreme example of this
stagnation).


Not specifying the result of a shift because the implementation is
inefficient on some machines is an extreme example of timidity.
(Mathematically, shifting by 2N bits should be semantically equivalent
to shifting by N bits twice, regardless of the value of N!)


Back in the good old days, language designers developed powerful
languages regardless of implementation efficiency, and hardware
designers responded by developing hardware to implement these powerful
languages more efficiently (hardware stacks, lisp machines,
content-addressable memory and so on).


The post by Hans-Peter Diettrich on Unum numbers is a small
encouraging sign.


--
Martin


Dr Martin Ward | Email: martin@gkc.org.uk | http://www.gkc.org.uk
G.K.Chesterton site: http://www.gkc.org.uk/gkc | Erdos number: 4
[I think you'll find that don't specify in ways that might be hard to
compile goes all the way back to Fortran. Its standards allowed
optimizations like strength reduction if they were mathematically
equivalent to the original code, even if they weren't computationally
equivalent. -John]

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