Academics should stick to pure computer science

Every time the academics try to wet their flaccid noodle in the soft, warm crevices of actual programming, they prematurely squirt all over it, and don't get any of their gooey information inside. I'm coming at this from the context of compilers, but I'm sure it applies to most areas. I don't think that anyone could disagree that tomes such as TAoCP are anything less than holy scripture and should be read by anyone who thinks to call them-self a programmer, but beyond that, it's done nothing but waste time. For instance, pure functional programming. Like most academic things, it promises beauty and simplicity and millions of optimizations that can be done. Where are these optimizations? In the math of course. Problem is, most of them never bother to implement them, and on the rare occasion that they do, it's some toy that only shows that particular optimization on a particular instance on a particular program.

The damage comes in when legions of pseudo-intellectuals argue for the style used on the basis that it can merely be shown to allow these optimizations. The rate at which such things actually occur are probably less than one or two percent. Besides looking particularly ``mathy'' in syntax, the result is usually purposeless and never delivers one any of the promises that were theoretically possible.

>>8
You can't really use OO's situation as an analogy to FP's, assuming that you take ``higher order function'' as the defining feature of FP like with OO's subclassing. Most FP languages aren't pure so what other choice do you have?
Unlike ``subclassing'' you can't go wrong with higher order function-it's actually fundamental to PL theory, and it won't create more problems than it solves. The only noteworthy problem of HO was the already solved FUNARG problem, and that was just a matter of implementation, not something inherent to HO.

OBJECT-ORIENTED PROGRAMMING with all its good and evil aspects, still has serious fundamental problems. One of the most disturbing would be this http://okmij.org/ftp/Computation/Subtyping/Trouble.html
In short, ``subclassing'' with ``overriding'' isn't really subtyping, because ``overriding'' violates subtyping's universal polymorphism. It's ad-hoc polymorphism in disguise, while convincing the type checker that a subclass instance still inhabits the superclass. No, it doesn't, and that means whatever you assert for a superclass will possibly no longer hold for a subclass AND CHECKING THIS IS AN UNDECIDABLE PROBLEM.
That is the subtle reason why all modern ENTERPRISE QUALITY INDUSTRIAL BIG DATA AS A PLATFORM CLOUD-ENABLED MACHINE LEARNED INTELLIWARES are so ridden with lurking unreproduceable BUGS

Alan Kay's idea of message passing on the other hand is fine, unfortunately most OO languages don't actually have message passing and instead shove A.m() down your goyim throat and call that ``message passing''. Too bad some of the few language got message passing right are Erlangs and its spawns, which identify themselves as FP languages.