←back to thread

Learn OCaml

(ocaml-sf.org)
203 points smartmic | 4 comments | 27 Jun 25 20:36 UTC | HN request time: 0.498s | source
Show context
another_twist ◴[28 Jun 25 05:13 UTC] No.44402433[source]▶
Is OCaml still worth learning these days ? Feels like plenty of languages are evolving quite well and most things can be done in imperative langs like Go/Java with pretty concise code and certainly better perf.
replies(6): >>44402448 #>>44402524 #>>44402790 #>>44404250 #>>44405117 #>>44408867 #
yawaramin ◴[28 Jun 25 05:45 UTC] No.44402524[source]▶
Both claims are debatable.

Pretty concise code: Go code is full of `if err != nil {...}` song and dance and they seem pretty committed to keeping it that way. Java is stuck with decades of decisions and libraries made in their early days because they can't break backward compatibility. Eg, all the standard library collection types are mutable. And of course, both of them have the 'null pointer' problem, which OCaml doesn't.

Meanwhile OCaml has had the same main type-level tools (record types, variant types) and techniques (pattern matching, first-class functions) since the very beginning and those are still the workhorse till this day.

Certainly better perf: I'd say that really depends on how much tuning has been done. OCaml applications by default are fairly performant and with OCaml 5's multicore support and effect handlers will unlock even more performance wins.

replies(1): >>44402593 #
1. another_twist ◴[28 Jun 25 06:06 UTC] No.44402593[source]▶
Go is definitely full of these issues. Java has pretty good perf out of the box due to JIT. The libs may be old but they do their jobs really well. Some common ones like Guava are updated as new features become available. Tbh the collections being mutable isnt really an issue since it gets the job done and reasoning about these things isnt that hard. However I do prefer immutability wherever I can get it.
replies(3): >>44403731 #>>44405727 #>>44417715 #
2. Quekid5 ◴[28 Jun 25 10:49 UTC] No.44403731[source]▶
> Tbh the collections being mutable isnt really an issue since it gets the job done and reasoning about these things isnt that hard.

Have you worked in language with immutable collections by default? It's night and day -- no more defensive copies, no more weird ImmutableList wrappers (Guava) which will (interface-wise) say they're mutable but will throw at runtime, no worrying about multithreading, cheap subsequences, etc. etc.

The difference is so stark that I would literally choose a worse[0] language(!) over a better one if it had immutable collections by default.

EDIT: Since you mentioned Java in a sibling comment -- give Scala a try and try working with the collections there.

[0] Within reason, of course :)

3. akkad33 ◴[28 Jun 25 16:06 UTC] No.44405727[source]▶
Why are all java apps super slow like Intellij and require you to play around with heap memory with things like xmx min max etc? I write Java code for a living and it's so dependent on frameworks to do many basic things where you can't really reason about the code. Subtle bugs can come from mutability here, nullability there, hidden state in another place and most coding styles rely on these and use them because it is so easy to do. It's possible, but not idiomatic to write immutable stateless code in Java. Coding in Java is now much more pleasant with records, optionals, sealed interfaces and streams, but it's interweaved with old coding styles so that it negates most benefits of the new patterns
4. throw234234234 ◴[29 Jun 25 23:50 UTC] No.44417715[source]▶
YMMV but I find Java perf less even with the JIT than OcAml/F# .NET/etc for tuned code which generally is what matters when performance is a concern. The auto-boxing, lack of proper generics, etc really make it hard to do re-use in a performant way especially around math like apps, especially if they use any of the "Big" boxing types. There's too much heap allocation you can't avoid. Better than say Node/Python but even F# in .NET will generally do better here in my testing with inline templating/stack types/spans/etc.

Languages with immutability/lazy seq/etc support built in can be tuned faster than a library (compiler help around sequences/streams rather than pure library based ones), and again the lack of stack types can make some of these immutable collections much slower/take up more memory than other language targets. There's algorithms I can't use in Java which I can use in .NET/Rust/C++/etc without memory penalty or lots of unsafe/hacky code.