Where is the innovation in software?

The factors included: multimedia-capable PCs, broadband and cell-phone cameras. All driven by Moore's Law.

A great deal of compsci seems to be like this (even including new ways of multiplying numbers) - not surprising, since Moore's Law dwarfs all other forces. No other industry has anything anywhere near comparable.

This can be used predictively: what obviously great but ridiculously infeasible idea will Moore's Law soon make feasible?

Examples: spherical TV (you sit inside); golf-swing analysis by brute-force matching with 3D recordings of every possible swing (to arbitrary resolution); literal recording and playback of 3D cerebral cortex activity (to arbitrary precision).

The whole argument about macros as a replacement for "static higher order programming," which is supposedly better than "dynamic higher order programming," which evidently nobody needs, was lost on me. He also seems to be saying, though, that "dynamic higher order programming" does not include closures, so I really don't know what it is. If a closure is anything, it is certainly a function created at runtime.

He also seems to say a function composition operator is obviously bad, without any justification. I guess if justification were required, it wouldn't be obvious. I don't see the clear advantage of carrying around a data structure with multiple functions and a third function that composes them, versus just using a compose operator. I suppose it's a little more opaque, but that is often a good thing (a kind of encapsulation).

"Of course, it may be slightly easier to optimize the result of dynamic code generation"

But maybe it's a lot easier? Can we get a huge speedup, or just a little one? I have no idea, because he doesn't say, and it's not even clear if he knows.

"Whatever problem we are solving by constructing h(x), it is probably better solved by a macro, which would perform the same composition statically."

I highly doubt any serious Lisp programmer agrees with this statement. Dynamically constructing functions at runtime is an extremely common lisp (pun unintended, but fortuitous) technique.

I have not programmed in Haskell, but reading this gives me no legitimate reasons to think it is a bad language, let alone an indictment on CS research.