ML and Haskell have amazingly powerful type systems. Their type systems, and to some degree syntax, have widely influenced the modern crop of languages. Both can achieve machine performance. Haskell has fantastic concurrency. Both have concise, boilerplate-free syntax -- some would say too concise. Both have the ability to build abstractions without impacting performance.
So why aren't there more Haskell or ML programmers? Like, it's fantastic that Rust and Swift borrowed some of their ideas, but why did it take two decades? Why do things like CoffeeScript and Go spread like wildfire instead? Go is especially bizarre because it's not really very different from Java in many ways, and a lot worse in others.
I'm sure there are many reasons. Tooling is important. Marketing is important. Haskell is (or perhaps just was) largely a research language. The first-time user experience is important. I don't claim to know every reason why some languages spread and others don't, but I know at least one thing: syntax matters a whole lot more than we'd like to admit.
Consider all of the bracing and spacing and indentation arguments people have about C.
Remember that brilliant people have whined about the fact that Python uses whitespace to indicate nesting, as if that materially affects how much work they can get done.
There are two ways to interpret this phenomenon. One is "stupid humans and their quirks and biases, if only the uneducated masses would see the light and focus on what really matters". Another is the realization that programming is a deeply human activity. A programming language lets humans take their human thoughts and map them into something a computer can execute. The aesthetics of that activity are important.
If a language is going to get adopted, at least without significant corporate backing, it needs to appeal to peoples' tastes.
Back to Haskell and ML. They have their proponents, but it's only until now that they're starting to dance with the mainstream. It's a shame, because software would be in a much better place if all the material benefits of ML and Haskell (bidirectional type inference, cheap and safe concurrency, sum types) had spread faster.
I'll share some relevant experiences.
My personal OCaml experience occurred in university. One day I decided to play with this OCaml thing. My rationale is perhaps embarrassing, but I quit for two reasons: the addition operator for integers is
+ but for floats it's
+.. The other thing was the pervasive use of
;;, at least in the repl. Honestly, it felt tasteless, so I dropped it and moved on, never getting to see the real benefits (polymorphism, type inference, modules, sum types).
Now, Haskell. I was part of the effort to get Haskell adopted at IMVU. The benefits of using Haskell were simply too great to ignore. But when we tried to get everyone to learn it, a nontrivial fraction of engineers developed a visceral aversion. "I understand all the benefits but... I just hate it." "Why do you hate it?" "The whitespace, $, the two let forms, the weird function names... I dunno, it's just ugly and I hate it."
It made me deeply sad that these seemingly superficial complaints prevented what should have been a slam dunk, at least when it came to safety and performance and maintainability and development speed.
When I joined Dropbox, I had some conversations with teammates about the benefits of something like Haskell (most people either don't know about it or think it's some academic obscurity), and I got a serious negative reaction to the idea of static types. "They're heavyweight." "They're hard to learn." "They hinder refactoring." "They hurt development speed."
None of these are necessarily factual. After I poked and prodded, I figured out that the resistance to the idea of static typing comes from prior exposure to things like C++ or Java (or Go), which have especially verbose syntaxes and type systems. This is similar to what happens with functional programming, where a common reaction to the idea is "Ugh, I hated my lisp class in college."
In subsequent posts, I will describe some of DFPL's design decisions.