[ralphc]

In my progression of Haskell-OCaml-Common Lisp-Clojure-Scala, I remember OCaml having odd edge cases, modules of functors or some such that didn't really help me in solving real world problems (this was 2007-2008 so my memory could be off). I'm currently a fan of Scala, which has all the functional and Algebraic Data Type goodness I remember from OCaml but is more "practical", more companies and projects are using it, plus I work in the JVM ecosystem. Any reason to go to OCaml now instead of Scala?

[elehack]

It depends on what you are working on. OCaml lets you interact more closely with Unix and with C libraries, if you need that. It also has a lot faster startup time and lower memory overhead, making it somewhat more suitable for writing Unix-style programs that need to run quickly with low overhead.

I also moved from OCaml to Scala for my primary programming, and have really enjoyed it. The functional goodness on top of JVM is a major win for the kinds of things that I primarily work on these days.

When I was working with OCaml, the community was going through a lot of work on figuring out what the ecosystem should look like. This involved at least two competing standard library extensions or replacements (Batteries and Jane St. Core), growing pains in packaging & deployment, etc. The language was (and still is) nice, but I could not, at the time, invest the time into dealing with the ecosystem. Things seem to have improved a lot since then, particularly with things like OPAN emerging, but Scala is still a better fit for the work I do, and Haskell has been serving me well for command-line kinds of things. But OCaml is a fine, practical language for a lot of things.

[jimbokun]

Is OCaml, then, a good fit for the kinds of programs many people have started writing in Go?

Native, stand alone binaries. High performance (not sure how the Go vs. OCaml benchmarks look right now). Good networking. More productive and less error prone than C or C++. Less verbose than Java.

Haven't written any OCaml programs, but seems to check the same boxes. Go seems to have a much better concurrency story with channels.

OCaml seems to have a much better type system and functional programming support.

[elehack]

Go does have a much better concurrency story, OCaml's is rather weak (as others have observed).

For the work I do (data analysis and scientific research, particularly on recommender systems, with system-building to support that), if I need concurrency, it's suitable to run the program on the JVM. So I would use Scala in that case, and OCaml would be fine for the other systems-y stuff.

I personally have taken to writing such code in Haskell these days, but that's largely to practice my FP skills in a manner that's easier to transfer back to Scala.

[dllthomas]

My understanding is that Go has a focus on concurrency which OCaml presently lacks, and so it probably has an edge there (possibly a big one). Otherwise, yes, OCaml is a good fit for the kinds of problems I understand Go to be used for.

[edwintorok]

If you only need concurrency for I/O, and in particular networking then OCaml is pretty good here:

- you can use system threads. Yes you'll only be able to run one OCaml thread at once, but when one OCaml thread gets blocked on I/O it switches to another.

- you can do co-operative threading if you write your code in a monadic style (there are a few libraries providing this: Lwt, Async, and in some sense Equeue). Then you don't need to worry about the thread/context-switching overhead, and the event-driven architecture should allow you to scale to thousands of concurrent events. While this may sound scary at first, the syntax is quite easy to understand, and it really is a lot easier than trying to write non-blocking code in C with lots of callbacks.

In particular have a look at Ocsigen, and Eliom that provide a web-server and framework: http://ocsigen.org/tutorial/

Regarding the book have a look at the 'Concurrent Programming with Async' chapter that shows how you can write a TCP server/client that doesn't block.

[dllthomas]

Good points.

[gaius]

Once you get used to OCaml's type inference that just works, Scala seems a bit clunky.

[avsm]

Marius Eriksen (who leads a lot of the Scala work at Twitter) gave us a great quote for the back of the book that says it best.

    Programmers are digital choreographers, carefully 
    balancing correctness, modularity, concurrency, 
    and performance. Real World OCaml teaches you how 
    to perform this balancing act in simple, elegant ways.

OCaml's the simplest systems language I've ever used with a decent static type system to prevent common errors from creeping into your code (most other systems languages sacrifice modularity in favour of even more simplicity, but OCaml strikes a balance).

[tomp]

For me, OCaml is just easier on the eyes. For example, compare ADT declaration in OCaml vs. Scala case classes.