John Backus: turd pusher

https://en.wikipedia.org/wiki/Von_Neumann_programming_languages
https://en.wikipedia.org/wiki/Talk:Von_Neumann_programming_languages

Backus tried to pass this off as scientific, but he was really passing turdware onto unsuspecting goyim.

It was the foundation for funding a whole class of programming language: the functional language with lazy evaluation.

Haskell and ``FP'' are also ``high-level abstract isomorphic copies of von Neumann architectures''.

declarations ↔ computer storage cells
pattern matching ↔ computer test-and-jump instructions
lazy evaluation ↔ fetching, storing instructions
expressions ↔ memory reference and arithmetic instructions.

The ``von Neumann bottleneck'' should be considered a financial bottleneck for ``PLT'' ``research''. ``Eliminating'' it with FP allows researchers to get grants for almost anything, without having to demonstrate any real-world benefits, because they say Backus already demonstrated them.

http://haskell.cs.yale.edu/wp-content/uploads/2011/02/history.pdf

The genesis of Haskell
In 1978 John Backus delivered his Turing Award lecture, “Can programming be liberated from the von Neumann style?” (Backus, 1978a), which positioned functional programming as a radical attack on the whole programming enterprise, from hardware architecture upwards. This prominent endorsement from a giant in the field—Backus led the team that developed Fortran, and invented Backus Naur Form (BNF)—put functional programming on the map in a new way, as a practical programming tool rather than a mathematical curiosity.

>>4
There is nothing in this paper about ``increas[ing] the body of knowledge to mankind''. It is entirely about alleged real-world benefits to ``functional programming'' which have been proven wrong again and again.

People have been trying ``functional programming'' for more than 50 years and not one of these benefits has ever been validated.

https://www.cs.cmu.edu/~crary/819-f09/Backus78.pdf

>>6

No one puts money into a sink with no benefits.

People do because of the power of the scams. They say it makes programming cheaper, faster, more reliable, more secure, and the programs run faster.

Meanwhile, they don't do any research on normal (imperative) programming. Most of the real-world concurrency and proof techniques are from the 1970s and had nothing to do with the Backus or lambda calculus forms of FP. Functional programming takes the most money and produces the least value.

>>7
Backus wanted ``appers'' to be able to code. He said ``functional programming'' would make programming cheaper and more reliable. The fact that Haskell even exists is proof that he was wrong.

but the plain fact is that few languages make programming sufficiently cheaper or more reliable to justify the cost of producing and learning to use them.

``Functional programming'' is only suitable for toy problems like the recursive Fibonacci sequence and recursive factorial. Any time you add IO or error handling, ``functional programming'' falls apart.

Even Haskell was a toy language until they used the 1970s approach to imperative programming from domain theory. state -> (state, result) is straight out of the 1970s.