Let us assume, for the sake of argument, that learning Clojure is not the only worthwile persuit in life

Let us assume, for the sake of argument, that learning Clojure is not the only worthwhile pursuit in life. Let us also disregard worthwhile pursuits other than programming.

Clojure is not meant to be an isolated island. Rich Hickey has made that case better than I can.

In addition to Clojure, what other two programming languages are worth learning to complement Clojure? I am especially interested in the reasoning why. Are you looking back on your experience, finding that you’re so happy you learned language/ecosystem X before coming to Clojure? Or is your hindsight telling you that you should have learned something else? Please explain.

In answers, I’m accepting both “You should learn Java because of Maven’s vast value”, or “I’m not mentioning Java because you’ll have to learn a bit of Java regardless”. I’m more interested in the rationale than the choice.



Absolutely Java and JavaScript since they will strengthen your understanding of Clojure(Script). Knowing what the JVM is capable of and having the option of dropping down to Java if you really need to do something performance critical is like having a super power. You don’t need to do it often but having the option to do so is great. Same applies to JS. Knowing how and when to leverage the Host is critical IMHO.

Besides that I’m fond of Erlang. The real Erlang not others based on it like Elixir. It is a rather niche Language and definitely best suited for very high concurrency network type application (eg. many millions of connections). It was built for that and the programming model reflects that. I wouldn’t call it a general purpose platform but for its niche its nice.

But to be honest every language I used in my carreer taught me something valueable. I would never want to use PHP again but it would still be valuable to learn since it is still one of the simplest ways to get something going on the web.


How about SQL? It is the lingua franca of data, even if you prefer other query languages.


For pure breadth of knowledge and wisdom, perhaps learn:

  • C
  • an APL family language. Say J.
  • Erlang
  • Prolog
  • Smalltalk
  • Haskel
  • a LISP (say Clojure, tick)

Apart from that, there are the “pragmatic languages” like python, Javascript and Java. But they won’t really make you wiser, just more employable.

But, yes, Javascript and Java are the two primary “host” languages for Clojure, so those two win at a pragmatic level.

  • Spanish
  • German
  • Zig
1 Like

The great thing about Lisp dialects is that they can accommodate different programming paradigms more easily than most other language syntaxes. In my case I will probably stick with Clojure for most things, but learn other languages to expose myself to different paradigms. Many people learn Lisp for the same reason (e.g. homoiconicity, macros, REPL workflow).

Personally, I’ve started learning Prolog. Not because I think Prolog in itself is a practical language in today’s world, but because I believe the Logic Programming paradigm itself is worth learning. And obviously lots of Clojure libraries are derived in some way from Prolog (and RDF) or logic programming as a paradigm.

For the same reason, I imagine Haskell - being the prototypical, mathematical functional language - is probably worth learning. Or at least, looking from the outside in, it sure looks like haskellers all speak a special language and I would like to learn it someday.

Erlang/Elixir for a similar reason. Probably Rust too for its memory management.

Another reason to learn a language might be to increase your chances of getting employed or increasing the breadth of libraries available to you. In that case, I would just learn whatever mainstream language peeks my interest (that I don’t already know).


Learning Haskell has definitely taught me how to utilize strong type systems. That is interesting in the solving-a-puzzle sense, but also in the practical sense. Even with dynamic types, having a good idea of the structure of values is important, and Haskell has helped me build that mental model. It has also made exploring the type systems of other languages much easier, and made it quicker to figure out whether I can do what I want with them or not.


Java and JavaScript and it ain’t even close. In a very deep and real sense, Clojure is host interop (in usage, not just implementation), so fluency in the host language/platform is kind of important. Those are definitely the best to already have under your belt when you come to Clojure.

If we can set those aside for whatever reason, IMO the most important guiding force is finding the weird & valuable language that captures your interest. There are plenty. To start at random: Erlang and Haskell, for the kinds of reasons Rich describes in this 2010 interview with Dirk Elmendorf:

DE: So are you trying to create something that is missing from other languages?
RH: Well, I mean I’m borrowing as much as I can from wherever I can for sure. I definitely stand on the shoulders of giants. But in this area, I never claim any novelty for Clojure. Clojure is mostly about trying to take existing good ideas that may not have been put together and put them together. It’s certainly missing from the more traditional languages like Java, C# and C++. But, there are other ways to address it that are present in Erlang and Haskell, for instance.

(I think he elaborates on at least one of that Haskell & Erlang point in this great Expert to Expert interview.)

To that list of “languages that incorporate good, old, mostly-ignored ideas” or “mind-expanding languages” I’d add:

  • APL – this great Aaron Hsu talk may whet your appetite
  • another lisp – I like Racket, but Scheme’s “from the simplest building blocks” approach is nice, and Common Lisp is good to understand Clojure’s origin story
  • OCaml
  • Prolog, for Simon’s reasons :slight_smile:

Thanks for all the great answers! :blush:

I have lots of interesting threads to dig into now. That being said, more opinions are most welcome!

I’ll add another :+1: for both APL and Prolog. I’ve worked at companies that used those languages, although I was originally exposed to Prolog at university (early '80s).

I worked at an insurance company during my “industrial placement” year as part of my BSc in Math/Comp Sci back in the UK (doing COBOL and assembler) and they used APL for ad hoc numerical data analysis and I was so fascinated by it that I chose to write an APL interpreter as my final year project for my bachelor’s degree.

Later, I worked at a firm of actuaries, doing Parallel C (for Transputers) and they had a Prolog team that I kind of hung out on the fringes of (when I decided to leave, they offered me the lead role on the Prolog team to try to tempt me to stay!).

Both languages are radically different from any mainstream language and that is why you will gain new insights from learning/using them. They’ve always been #1 and #2 on my list of “alternative languages you should learn”. #3 and #4 are Lisp and Smalltalk. We all already know “why Lisp” but Smalltalk is definitely worth a look because, again, it has some radical aspects (dynamic OO with message-focused semantics, rather than method-based, and a fully-interactive environment where everything is an object that you can inspect and modify as an extension of whatever code you’re writing).


I coded in PostScript for many years. That I can really recommend. It’s addictive in similar ways that Clojure is. Very dynamic. It’s idiomatic to write programs that modify themselves as they run.

Also have very fond memories of coding my HP34C. Similar to PostScript in how it made me think in the language.

Got to say that I feel very productive coding in TypeScript. My brain just very quickly figures out how I should solve things. And the way I can opt in on typing is very nice.


first of all; great topic title :+1: :smile:

now because you phrased your question in rather specific terms ( clj to u is meant to also include cljs, correct?), i think you got a great answer right away. :smile:

THAT ( to me at least ) MAKES PERFECT SENSE!

p.s. for some more rationale along those lines consider the following post i wrote a while back:


My background was mostly compile-to-js languages, CoffeeScript, ClojureScript, TypeScript… And last year I started using Nim for some of my personal projects. Of cause Clojurescript is the language that has most influences to my current code style, but meanwhile I found myself limited by the dynamic nature of ClojureScript. And Nim enlightened a bunch of concepts related to memory layout and data structure, that made me realize there’s still wide world out of dynamic languages. Clojure(Script), like other dynamic languages, in their natures, build abstractions on top of data structure and users may be limited by this concept.

Well, your mileage may vary if your first languages are static typed ones. Nim is an indentation based syntax language that internally compies to C/C++ to run, so it brought many concepts from C to me.

Meanwhile I have long interest in Haskell, and planning to learn PureScript. ClojureScript is depending too much on Google Closure Compiler and got less interest in making catch up with features of modern browsers. I suppose PureScript and Rescript, being younger and more active, would integrate themselves into modern JavaScript better.


Nobody mentioned Red nor Rebol.
Two of the most “meta oriented” languages I think.
Based on something similar to Fexprs which are (kind of) a generalization of macros.


I’m not sure whether this is a reason to learn other languages, but one of the things I’ve been struck by recently is how much easier some things are in one language or another. So maybe a reason to learn a language is because it will make certain things easier.


In Clojure, if you need an infinite sequence, that’s easy because lazy sequences are a default. I tried to do the same thing in OCaml, another language I like, and though there are libraries for it, I finally decided it hadn’t been worth the trouble to use lazy sequences. OCaml is a nice language, but this is not what it’s designed for.

Later, I wanted to write some code to help me think about some infinite tree structures that were the basis of some mathematical ideas. At the time I was learning Haskell, and it was the perfect language for an infinite tree. Since pretty much everything’s lazy by default in Haskell (outside of the dreaded monads), it was trivial to write the data structure. Later I tried to figure out how to do the same thing in Clojure, and decided it wasn’t worth the trouble.


I’m a Mechanical Engineer that started programming in the early 80s. My first experience was implementing a FORTH dialect in assembly on a mini-computer followed by another FORTH on the original IBM PC, including it’s own IO round robin OS sitting directly on the BIOS i.e. no MSDOS.

I used a book titled Threaded Interpreted Languages as a guide.

These experiences have served me well. There’s something powerful about having worked on the metal, and built your own language and OS.

I’ve often thought about offering a community course in building a language and OS from scratch.


( me too :smile: )

sounds like an extremely ambitious undertaking to me, but if this is something you wanna do, i say: go for it!

1 Like