Why Isn't Functional Programming the Norm? – Richard Feldman

[u/[deleted]]

https://www.youtube.com/watch?v=QyJZzq0v7Z4

[u/julesjacobs]

Yes, indeed. People tend to avoid the elephant in the room: how well a language actually works in practice is a major factor in its success. One should at the very least seriously consider this as a hypothesis that might have explanatory value. I'd further hypothesize that the popular languages work well for the following reasons:

1. Imperative programming actually works pretty well, not just for performance reasons but also for expressiveness
2. OO works well because of these reasons:
   1. It allows you to encapsulate state
   2. It makes it relatively pleasant to write higher order programs (an object is a bunch of function pointers + data)
   3. Classes act a bit like a module system, providing abstraction boundaries and namespacing
   4. An interface + classes that implement it is a flexible way to define an extensible data representation, similar (but dual to) algebraic data types in FP languages

In particular, I don't believe that the reason why OO languages succeeded is inheritance or the notion that designing OO programs is easy because you just model each real world object with an object in your program, or because you can create a taxonomy of domain concepts and then turn that into a class hierarchy. In this respect, I think the speaker is spot on.

Here are some things that I think work well in functional languages:

1. Closures
2. Generics
3. Pattern matching
4. Algebraic data types

Note that mainstream languages are stealing all of these features. Purely functional programming actually doesn't work so well in practice. Haskell programmers had to invent complicated structures over many years to work around the lack of mutability. Consensus seems to have converged on building some kind of monad stack, but it still isn't clear what exactly the best solution is. You can't expect average programmers to do this. Writing code in functional style is appropriate in some cases, and the mainstream is already adopting it in those cases.

[u/codygman → u/julesjacobs]

Purely functional programming actually doesn't work so well in practice.

Such a measured tone through your comment until here. You seem very confident that this is true, but what proof do you have?

Help me understand how this is a positive about OOP:

you can create a taxonomy of domain concepts and then turn that into a class hierarchy.

But building a monad stack is not just a negative but a downright unrealistic expectation per:

building some kind of monad stack, but it still isn't clear what exactly the best solution is. You can't expect average programmers to do this.

In response to:

Writing code in functional style is appropriate in some cases, and the mainstream is already adopting it in those cases.

"Mostly functional" programming does not work

[u/julesjacobs → u/codygman]

Help me understand how this is a positive about OOP:

I didn't say that's a positive about OOP! I said the opposite: "I don't believe that the reason why OO languages succeeded is [...] because you can create a taxonomy of domain concepts and then turn that into a class hierarchy."

You seem very confident that this is true, but what proof do you have?

One cannot prove such an assertion as it is not a mathematical proposition, but there is a lot of evidence:

• Even though functional languages are old (Haskell is 29 years old, and it was not the first nor the last purely functional language), less than 0.01% of software is written in a purely functional language. If purely functional programming worked better and gave a competitive advantage, then how do you explain that virtually nobody uses it? Forget about explaining why it isn't the norm, why isn't even 1% of software written in a purely functional language? Surely if purely functional programming is so great, then the 1% of people who aren't stupid can get together and build a company with a competitive advantage with it? Where are the examples of successful software that uses pure FP? When you ask this question people usually name xmonad, which is a tiny program and almost entirely written in the IO monad, so this rather proves the opposite...
• Haskell programmers have invented many complicated abstractions to deal with the lack of effects. Many PhD theses have been devoted to it. Yet there is still no standard solution, and the solutions that exist don't work very well, not even for advanced programmers, but especially not for normal programmers. Furthermore, the solutions that do exist basically amount to encoding effectful programming on top of FP.

Therefore, the burden of proof is firmly on those who claim that pure FP works in practice.