Two years ago, I stood on my soapbox and yelled. I told the FP community that their languages were bad, and that they should feel bad. It was a post full of vitriol and frustration, but also a little bit of truth. I believed then (and still do) that functional languages are a poor solution if what you're looking for is a way to get B grade programmers to build scalable, concurrent systems. After trying to learn Erlang, Haskell, and then Scala, I couldn't see how using those languages was easier that just using separate processes, stitched together with message passing infrastructure, to build systems at scale. And with these thoughts running through my head, I vomited on the Internet. Then Hacker News picked it up.
As is the custom on the web, almost none of the people who left comments actually tried to refute the central point of my post. Most of the responses I got were as angry and bitter as the post itself. I guess that's more evidence that, in this world, you get what you give. Thankfully though, some commenters were kind enough respond to my anger with offers of help. Some shared (rather excellent) resources for learning, others simply offered encouragement. But the most striking thing was a pattern that emerged from the comments that did offer a counter to my central point. They all said the same thing: Try Clojure.
After working with Clojure for the better part of this year, I can see why. Clojure is truly a joy. So much so, in fact, that I'm using it for some production systems at DRW, and on some of my side projects. Many of these systems are highly concurrent, doing work on dozens (and sometimes hundreds) of threads in parallel. The code is easy to reason about, easy to read, and easy to test. So I have to apologize for taking what was a reasonable critique of various people promoting FP, and wrapping it in a very poorly written rant. If I had decided to learn Clojure first, and had some success with it, maybe my post on FP would have been a little less rant-y.
Even so, I'm glad to see that what got me so worked up in the first place has started to fade. People no longer seem to be equating The Death of Moore's Law to "Everyone must learn functional programming, now. I understand why it's sometimes necessary to use hyperbole and bold claims to get people's attention. Once you have their attention, you can get your real point across. I just wish the focus back then was more on "[language] is awesome because of [language/platform feature]" and less about how we're all going to be out of a job unless we learn Caml (see what I did there?).
In some ways, I feel like the FP community made the same mistake that people made with OOP 15 years ago: They turned a good idea into a fad. It moved the discussion away from the true merits of a language, and into the realm of doom, gloom, and hypothetical situations. People could clearly see that there is more than one way to skin a cat, especially on the web, where scale is often a requirement. But some FP proponents tried to cast the end of Moore's law as the end of all imperative programming...which is just silly. In any case, I think the fad is over, and most of what's left is truly good and useful. Introducing a functional language into your codebase still won't turn your team of B grade .NET developers into a bunch of roflscale ninja rockstars, but I don't think anyone's implying that anymore.
Let me end by passing on the advice that was given to me over two years ago: If you still haven't tried Clojure, I really suggest that you do. The 4Clojure puzzles are a great way to get started. They're actually quite simple (until they're not...that's the fun).