OCaml for the Masses
queue.acm.org
queue.acm.org
JavaScript development these days is getting pretty darn close to what I would consider 'mainstream' functional programming.
Heavy use of both first class and lambda functions, and closures have been standard practices for years now. And thanks to libraries like Underscore.js partial application and the use higher order functions like map/filter/etc are also becoming very common place.
I'll absolutely agree that what we see is not 'pure' functional programming but neither is a good deal of real world Common Lisp.
Anyone who has done a lot of programming in Lisp or Haskell has probably bemoaned the fact that many people are quick to dismiss so many great and useful tools these langauges provide. But I definitely think we're starting to see a trend where the most genuinely useful features of fp are becoming mainstream.
I don't know, in general, that they're the "most useful" if utility is defined as conferring the ability to write better programs more quickly, more understandably, &c. But they are "most useful" in the sense that they confer such benefits with a minimum learning curve and with little deviation from the already understood mainstream programming paradigm. For example, monads are an incredibly useful feature, but the (perceived) barriers to understanding are high enough that no mainstream language will feature them as centrally as Haskell does.
I don't mean this as a sleight against anyone, at all—merely as a description. There are a lot of useful things which are outside the purview of the mainstream, and there's no reason to expect that nonetheless useful features of fp will necessarily make it into the mainstream. (And there are certainly cases where functional programming as a whole, and not just cribbed features, is desirable and advantageous, as in Jane Street's case, so I do hope that more non-academics come to see it as a valid paradigm for certain tasks.)
This write-up describes the basics of ocaml and haskell and some of their individual strengths. (along with scala and scheme)
That depends on the extensions you are using.
The biggest difference between the typesystems in practice seems to be the ubiquitous use of type classes in Haskell. OCaml's modules can do the same as type classes, but they require annotations and aren't used as pervasively.
Extensions to the type system are really different, OCaml's is more flexible and specific, but Haskell's is very convenient, but by the time that becomes an issue you'll probably know a lot more of how the languages differ.
Did you want to say that they are pretty similar? Or semantically different?
Ocaml: strict and impure if needed, but has everything you need to write great functional code (and not much more, which makes Ocaml actually fun to read; I can't say the same of that horror they call C++). I tend to think of it as a functional C. It's a bare-bones, simple language but it's awesome.
Haskell uses type classes for what Ocaml achieves more generally (but also with more work) with functors. Type classes are prettier. Functors handle complex cases (multiple related types) better. Hard call which is "better".
Haskell is more mind-blowing, Ocaml is more practical for most purposes, but probably not as practical as Scala. I like them both (and Scala).
Sadly, I wouldn't bet on either reaching the mainstream. Haskell is lazy, which makes it really hard to reason about memory usage. Ocaml's a great language, but the libraries available are quite poor and the effort to get it ready for multicore is DOA. I wish these languages have more of a future than I think they actually do. Now we're in the "raiding phase" where languages like Scala are borrowing awesomeness from them just like Ruby and Python did to Lisp 15 years ago.
On that, I think Scala's actually a good bet for the next 5 years, and not a bad language at all, although it's hard to learn because most of the online resources are pretty poor. (Odersky's Scala book is great.)
Edit: should have mentioned this earlier for an example - xmonad is written in haskell
And of course Minsky's employer, Jane Street Capital, writes everything in OCaml.
There are plenty of commercial users outside the financial sector too but those users tend to be smaller companies.
You are right, OCaml doesn't see too much use outside of Jane Street, Citrix and a few others. I think the academics mostly left it in favour of Haskell. Also the owner of the OCaml project didn't embrace community development early on. It's more like a cathedral than a bazaar. They are signs showing to change, but it's probably already too late for mainstream popularity.
http://www.haskell.org/haskellwiki/Haskell_in_industry has experience reports for Haskell.
Galois and Standard Chartered both have large Haskell teams, for example (I've worked for both).
I'm not sure about the performance issue. If it stays within a reasonable (low single-digit) factor I think the hit is worth the quality guarantees you can get out of it. The hiring/education issue is probably the #1 reason so few attempts are made in this direction.