Why I love OCaml

Every morning, I wake up and ask myself: why isn’t OCaml more popular? I mean, the language is not perfect, but the more I use it the more I feel like this old language had it all figured out, somehow. I mean, not in the literal sense: you write String.of_X instead of String.from_X because the language has French origins. But it is perfect in the sense that it has everything that is important to me, except popular adoption. OCaml has its quirks, its old age, but at the same time there is so much I appreciate about it.

I have some experience building amateur and professional software, in many different languages, and as a result I have collected a list of characteristics that I’ve come to appreciate over time. I think my journey into programming is different from many. I learned and adored functional programming before working in the industry, and while not my very first language, Haskell was important to me early on. Functional programming has allowed me to break big, complex problems down into subproblems that I know how to solve. It has made me a better thinker. Add to that the static guarantees of Haskell, which makes the mental overhead much lower than for other languages, and I am also more productive. Most importantly, with Haskell, I can focus more on the fun parts of programming.

However, Haskell’s issues lie in its immense complexity and slow compile times. I did say that Haskell lowers the mental overhead of programming, but that’s only if you use a small subset of the language. However because much of the community is very maximalist, introducing a lot of complexity into the code becomes inevitable. Much of the code you interact with is too “smart”, and becomes very hard to grok. Its runtime is also very complex, and there’s always the chance of running into notorious “space leaks”, that are extremely hard to debug.

At some point, I started exploring a language that is probably the polar opposite to Haskell: Go. With Go, I learned to appreciate simplicity and low-levels of abstractions, a good set of tooling, fast performance and fast compilation speed. I also started to appreciate good documentation that is easily available offline. The culture around Go also places a lot of value on simple solutions, which made interacting with the ecosystem easier. I can jump into any code base and understand what is happening.

Over time, I also grew to hate the issues that come with the language being so conservative: it is verbose in its error handling yet manages to be fragile. At the same time, it doesn’t have explicit null checks. These factors combined makes Go quite unpleasant and easy to write buggy code in. I also found myself missing a REPL or fast way of interacting with the program. The language is “predictably disappointing”, which I guess is a good thing. However, the solutions to those disappointments have been around before the language was even created and I am just left feeling that these solutions could have been implemented, and the compiler would not be much more complex as a result. It just genuinely felt like the Go language designers didn’t want to engage with any of the ideas coming from functional programming. But I digress.

From these experiences, a list of features I consider to be “good” features in a general programming language started to emerge:

• Fast compile times
• Fewer abstractions, and an easy to understand runtime
• Strong static guarantees
• Functional programming constructs. Especially pattern matching and sum types.
• Good performance
• Good documentation

And then, enter OCaml. This language just checks so many boxes:

• Strong static guarantees. Sum types, polymorphic variants, pattern matching.
• Simpler runtime semantics. OCaml is weird in that it’s a garbage collected language for systems, similar to Go. A seasoned OCaml programmer is probably able to gauge what the compiled assembler looks like just by looking at the code. That is a great quality.
• Fast compile times. When using Haskell or Rust, the slow compile times really kill your productivity. With Dune, OCaml compiles extremely fast. Faster than Go I believe?
• Similar to Go, OCaml can be compiled statically into a single binary, making it easy to deploy.
• Great documentation. OCaml has odig to browse documentation offline, utop as a REPL to explore code, and also separates interface files from implementation files. This makes it very pleasant to browse OCaml code. The types help guide the user.
• Automatically inferred types. I didn’t think this would matter, as writing out the types used to help my thinking. But now that I am more “fluent”, it is more typing and less code. In OCaml, modules separate interface files from implementation, and these are a better place to put types.

I’m left feeling that the authors of OCaml have good taste. It is an old language, and there are a few features that could probably be left out like the OOP-related features, and some libraries in the ecosystem over-complicate things like in Haskell. But overall, it’s just damn good. There are a lot of other features I appreciate about OCaml that I didn’t share. But to summarize why I love it: the right balance between simple and expressive, good documentation and good tooling.