Is Clojure too dependent of Rich Hickey?

I’m starting with Clojure and after spending some time researching I had the impression that Clojure is way too dependant on Rich Hickey. Not that this is bad, the guy is really smart but what if he dies?
There is any committee or community driving the language?

And a side question, is Clojure somehow stagnated or dying? I see very little interest in it. I know that the syntax can be a deal-breaker but as an awesome language as it is I would expect more interest/use.

Clojure isn’t dying, but it doesn’t have a large company like Google (golang), Microsoft (C#) or Sun / Oracle (Java) behind it. One of the deciding factors of a language becoming widely used is marketing. If you would make a plot of the money that went into Clojure’s marketing against how many people are using it, maybe it would score quite well. Maybe now that Cognitect is part of Nubank, they will have a larger budget (if it’s even a priority to do marketing, that I don’t know). A good talk that explains how this works is:

I’m sure the people at Cognitect have a plan in place in case something bad happens to Rich. At least they have admin rights to all the important things. But even if Cognitect would be erased from the planet due to some alien invasion (let’s hope not!), I think most people (myself included) could get by using 1.10.2-rc1 for at least a few years. The Clojure language and compiler is quite small and doesn’t move that fast. Due to Clojure being a Lisp, being the extensible and flexible language that it is, most of the action happens in libraries.


There’s no committee, but there’s a sort of community-ish. Clojure is mostly maintained by Cognitect (a small company), and some of their employees are the active maintainers of Clojure, including Rich Hickey. They do seem to have some internal process for language change and proposal that they review and discuss within themselves, but it’s not exposed publicly.

Recently they were acquired by Nubank (valued at 10B), a Brazilian unicorn in the FinTech sector of apparently 2500 employees which uses Clojure(Script) almost exclusively (from what I read). They said they’d continue to invest in the growth and development of Clojure, and that seems to have been the reason for them acquiring Cognitect.

You can read the post about it here:

On top of that, there are a few external contributors as well who submit patches and the like.

ClojureScript is maintained by the community mostly, with David Nolen at its helm. If I got my history right, he used to work at Cognitect, but doesn’t anymore, but still maintains ClojureScript where Rich Hickey is no longer involved.

I’d say Alex Miller is the public face of the Clojure core team, and he also looks absolutely capable of taking over the helm in an unlikely event.

So my guess is someone else at Cognitect would probably take over, and if that folded as well, I could easily see someone from the community taking over.

Clojure is also less effort to maintain than most other languages, because it delegates a lot to the JVM, so a lot of the hard work of actually keeping up to date with various operating systems and hardware systems is handled by the JVM, leaving Clojure to focus on the higher level stuff. Also Lisps in general tend to be “easier” to implement. That is a good thing, cause it mean it wouldn’t take a full team of full time devs to take over the development of Clojure, but only one or two dedicated smart developers.

That’s hard to say. Every year there’s a state of Clojure survey. You can see 2020’s here:

Based on the survey, Clojure’s use at work has been growing YoY, though at a slow but constant pace. Hobby usage seem to have plateaued, and thinkering is what’s down the most. What we don’t know is if the categories just traded with each other, people going from thinkering to hobby and hobby to work.

My impression is that Clojure has a small base of users, but that base is pretty healthy, but it’s not growing much. Unless people like you join off course :wink:

What I mean by that base being healthy, is that I don’t think Clojure user base is growing very much, but the eco-system is definitely growing and healthy and hasn’t stagnated at all in my opinion.

Part of the reason why is that most things have a kind of 1% rule, where 1% of the users contribute like 99% of the bulk of the interesting and unique features. Even in a bigger community, with say 100 times more users, you’d still only have a handful making interesting contributions. At least that Clojure seem quite active and healthy.

@borkdude is part of that actually, the man is a machine of open source haha, he brought us clj-kondo, sci and babashka all in the last year or two. Those are immeasurable contributions. And there’s too many to list, but the eco-system is doing well. Editor support is at an all time high. Build tooling has never been this good. The slack is still just as active as before. There were some pretty great Advent of Code youtube videos, I recommend checking out by the way:

I could go in listing more examples, like the MAGIC compiler to use Clojure for Unity game development, and others. Just to say, the ecosystem from what I see is quite alive and doing well, even if the user base may have not increased too much.

Edit: Oh and let me add that Clojure has a pretty healthy paid-for open source work as well. Clojurists Together ( funds 3 open source projects at 9k a quarter every quarter. And a few of the Clojure contributors have good patreon and github sponsoring. Cognitect even personally sponsors some of them: Which I was told they spend in the 6-digits a year on sponsorship.


I’d say that Clojure simply wouldn’t exist at all if it wasn’t for Rich Hickey, and at this point, it’s rock solid and stable and could be used as-is for decades maybe even if he stopped being involved.

Clojure’s development has been very measured – very conservative – unlike many other languages, to the point that code written a decade ago for Clojure 1.3 (or earlier) still runs unchanged in nearly all cases. That careful approach also means that prerelease builds are stable enough to run in production: we first went to production with an alpha build of 1.3 and we’ve run prerelease builds of every version of Clojure since then in production too (we’re running 1.10.2-alpha4 in production for most of our processes right now, with at least one process already on 1.10.2-rc1).

It’s also worth taking a look at the list of folks who have signed the contributor’s agreement – – and many of those have actively contributed to either Clojure itself or one of the many Contrib libraries that are managed under the same process (I can’t find the specific list of people who’ve contributed to Clojure core but even that subset of contributors is pretty long).

Clojure generally appeals to more senior developers who have experienced the pain points of other languages and other styles of programming and are quietly looking for “something better”, that enables them to do their job more productively and more effectively and so they mostly just go about their work without fanfare. Surveys have repeatedly shown that Clojure developers report themselves as the happiest, on average, of all developers (and that salaries tend to be higher, on average, too but that is most likely tied to Clojure developers being more senior on average).

A language doesn’t need to be popular to be successful – and popularity is a non-goal for Clojure.


Precisely. Like, all of the above.

The rock solid stability of the clojure language means it just cannot die. And how popular does a language need to be?

What I’m trying to say is: Rich Hickey designed Clojure in such a way that it actually is NOT dependent on him. Because he hates things like breakage by new versions, values simplicity. It’s a deliberately small rock solid generic core. It was meant to be like that from the beginning, and it still is. The word ‘bloat’ is hardly a thing in clojure-space, or at least it doesn’t get in the way. I love it for that.

It’s very very robust.

However: I say all this from a useability standpoint by the way, not from a language popularity standpoint. And I ONLY care about that first one for my own purposes (which is running a SaaS company using Clojure at the moment).


No, just no. :wink: