Is Clojure Dead?

I can say that I (like many others) have built a thriving career on Clojure. I like to change jobs every couple of years, and I've never yet had any trouble finding a Clojure job I'm excited about (and I only consider well-paid remote jobs with friendly teams with companies doing something I feel good about). The community is mostly active on the Clojurians slack (currently ~24,000 users) and clojureverse.org.

So -- it's a niche for sure, but a very successful niche, and one that many people are very happy in. There aren't a ton of jobs out there relative to, say, Python, but there are also fewer people competing for those jobs, so it works out fine for individuals. It can be tricky to find your first Clojure job, but I think that's true in most languages.

I plan to stick with it for the foreseeable future, because there's no other language that I like nearly as much, or can be nearly as productive in.

I’m going to be a contrarian here: the answer is yes.

Yes there commercial jobs out there, yes there are big names that use it, but it’s an increasingly insular community, it’s ceased growing, a lot of people have moved on, and it never really found a niche.

Established programming languages never “die” in the sense of dropping to zero, but to the extent that the question is meaningful, Clojure’s dead.

I find this hard to believe.

I believe you that you haven't see much about Clojure over past 2 years of so. But the cause might be that you simply haven't looked at Clojure in the past 2 years of so. OTOH, I've seen plenty of Clojure in the same 2 years. Perhaps most of news/fuzz is about Rust, but I haven't seen much of that, since I'm not following the news sources that talk about that.

In the end, it depends what you want to do. If you want a great programming language with vast ecosystem and decent number of job opportunities, Clojure is still the thing. If you wish to participate in the most mainstream thing, I believe the Python/Java/Javascript is the answer. But then you're competing with 30 million of other job seekers there.

Perhaps Clojure can't rival the Cardashians or Lady Gagas of this world in the amount of news (for better or worse).

Clojure is definitely not dead. There are active Clojure user groups in most countries (even in my little region) and i still (or even more than ever) stumble uppon cool and exiting projects and libs (e.g. https://github.com/borkdude. It's just incredible what a surplus value this dude alone provides to the ecosystem)

Clojure may not have the biggest audience but like others said, it generally focuses more on stability, so using libraries that haven't been updated a while is more of a plus-point and don't mean they are outdated.

Personally speaking, Clojure really brought back the joy of programming and i would never willingly go back to developing in a language without a REPL. The tight feedback loop you have while molding a running program in your editor and the constant dopamine drip feed it causes are just too addictive.

Clojure is the 3rd most liked [0] and 1st top paying [1] technology on the 2022 Stack Overflow survey.

[0] https://survey.stackoverflow.co/2022/#technology-most-loved-...

[1] https://survey.stackoverflow.co/2022/#technology-top-paying-...

Some of my favourite recent bits in Clojure:

https://www.hyperfiddle.net/

https://pathom3.wsscode.com/

https://github.com/HealthSamurai/matcho

Just got my second job in Clojure nearly getting on for double my before Clojure salary

1. No.

2. These languages were never very popular to begin with.

"I was seeing more HN posts about it in the past" doesn't equate to "the language was popular before and now it's dead.

I moved away from Clojure to Common Lisp. The Clojure culture doesn't take seriously developer experience, good documentation, easy getting started pages etc. Plus you have to deal with the JVM and slow compile cycles.

Compared to that Steel Bank Common Lisp is rock solid and just works. Even the libraries and documentation are fewer but better.

I did learn a lot from watching Rich Hickey's talks so there's that.

It's not DEAD as in no one is using it. A good friend who's crazy into Clojure still gets pinged a lot about Clojure jobs, but most of them are asking him to port Clojure to something else. Even he admits that as other languages' ecosystems continue to grow, Clojure is slowly being pushed to the background. He just finished a job to port Clojure to Python on some financial processing engine.

According to the the last StackOverflow Developer Survey [1], Clojure is the third most-loved language and the top-paid one.

Having writing Clojure daily for nearly 4 years, my experience fully confirms that survey.

I also noticed the apparent silence around Clojure and its community, which looks like a paradox to me [2]. The Clojure community is actually active and very supportive (the Clojurians channel on Slack incredibly helpful) but it's also very much low profile.

Rich Hickey created Clojure as an independent developer and without extra funding. He's a great speaker, but likely didn't benefit from all the marketing channels available to more popular languages designed in more corporate enviroments, such as Rust and Go.

Being a LISP dialect, Clojure is also quite niche (not the first language you'd learn at school/uni) and definitely not academic, but extremely pragmatical.

Learning Clojure was quite mind bending at first, and I often wondered by my more experienced colleagues kept saying how expressive it is. I now see their point, and get paid quite well for having spent time learning it.

[1] https://survey.stackoverflow.co/2022/

[2] https://piero.github.io/stories/2022/06/23/the-clojure-parad...

Plenty of anicdata here - so here my 2p: I started with Clojure about 5 years ago. Since then the community, tooling and job options have bloomed from my perspective. This could be an illusion caused by becoming gradually more immersed in it.

Clojure will not die for now, for the same reason that it remains nieche - it's a lisp. Arguably the only viable full stack web dev lisp. And lispers gonna lisp. If that speaks to you on a philosophical/aesthetic level then go for it, you will be in good company.

If you want to try to time the hype market then truly best of luck. However, I think choosing to invest in a language that works for you and your way of thinking will be a less fragile strategy.

I'll keep Clojuring for a while at least, because it's a pleasure. Because it lets me reason where other languages would have me memorise. I find memorising syntax tedious. It's not a silver bullet of course - some things just make more sense for to do in a c/rust type procedural language.

For the US, Google Trends reveals that Clojure's heyday came in 2013, and it has been on a decline since[0]. It never really reached the interest level of Scala, and of course recently Rust is consuming all the air in the room.

Except, just for kicks I add Golang, and it turns out that all of the above are marginal compared to Go[1].

HN posts are very different from general interest, but yeah, I'd go with "Clojure has sadly missed on its shot to become a popular general-purpose language" rather than "Clojure is dead," but your instincts seem right.

0. https://trends.google.com/trends/explore?date=all&geo=US&q=%...

1. https://trends.google.com/trends/explore?date=all&geo=US&q=%...

Been using Clojure for over a decade now, and I see these articles at least once a year. The reality is that Clojure is used more than ever today, with more libraries, tools, and companies around it. It was a viable language for many years, and the situation only keeps improving in every way.

Clojure simply doesn't have the hype around it because it's a mature and conservative language that's not chasing fads. This is a good thing because it's one of the most stable ecosystems I've had the pleasure to work with.

If you're looking for a hip new language then Clojure is probably not for you, but if you're looking to actually get work done using one of the best languages around then look no further.

I am learning Clojure right now and I can relate to the feeling of not wanting to put time and effort into it if there is no marketable value in return. One thing that is motivating me is I read an article about how niche languages can be lucrative. (I want to say that article was here on HN but too lazy right now to search for it). The other thing that is motivating me is that this type of programming and thinking is completely different to mainstream PLs. It is a fun and challenging exercise and my hope is that it will benefit me in "normal" PL like everyone says it will.

I do have a vague (unrealistic??) idea of maybe getting a PT job using Clojure after studying for a year or so. PT because my FT job has amazing benefits and career potential. We will see. As of right now I am just enjoying learning Clojure and Lisp-style language.

I mean... 1. https://clojure.org/news/news 2. https://ask.clojure.org/ 3. https://groups.google.com/g/clojure 4. http://planet.clojure.in/ 5. https://twitter.com/i/communities/1494013093059432451 ...make it seem as though reports of its death have been greatly exaggerated.

Clojure is a wonderful language, but not so wonderful that I can tolerate its slow startup and compile times. I think lots of developers think the same way. Imo any language nit facilitating fast startup and compile is stillborn. Imo the same goes for any language requiring you to setup a "project" or something to get started.

One benefit of learning functional languages, whether Haskell or Clojure, is that it makes you a better developer in other, non-functional, languages.

"Lisp is no more dead than usual"

Clojure is not dead. As a measure of community, the Slack workspace has around 25k members in it right now.

Even more, Clojure lives on through its various dialects: ClojureScript (JS), Clojure CLR, Clojerl (Erlang), Fennel (Lua), jank (LLVM C++), Ferret (LLVM C++), Babashka, Squint, and so on.

Definitely worth learning, as it will expand your mind; Rich Hickey's talks are some of the most influential I've ever seen.

Clojure is not dead, the core language is still very strong, but the dev experience has been degrading IME. This is due to a lack of heavy corporate backing and investment, probably by choice. Taking a PL to the mainstream is very expensive.

You cannot compare Clojure and Rust in any way as they're completely different design philosophies.

Can't speak to the others, but I'm pretty sure the F# team just doubled or tripled in size (it's still small though). Also the GitHub repo is very active: https://github.com/dotnet/fsharp .

> PS: Asking because I want to delve into a functional language but I cannot bring myself to do this seriously if it doesn't translate into market value.

learn a functional language because you want to learn a functional language. Learn whatever one sparks your interest.

It doesn't matter what one you learn because NONE of them have notable share in the job market. If you learn _any_ functional language you'll have a leg up on other applicants for _any_ functional language job because hardly anyone bothers to learn them. Also, there are so few jobs in functional programming that you're unlikely to get one anyway. So, again, just learn what you want to learn.

Clojure is very much alive. A dead language looks very different (Ceylon comes to my mind: https://news.ycombinator.com/item?id=31932085)

Some languages judge popularity based on "freshness", others on "quality" and others on other values, like "usage in enterprise" and other variables.

JavaScript ecosystem typically goes by "freshness" and "vanity stats", like GitHub stars or NPM downloads. An average JavaScript developer would check out a GitHub repository and look when the last commit was made, and if it's more than a year ago, decide the project might be too old and possibly abandon, and hence not look further into it.

In contrast, the Clojure ecosystem typically goes by "stability", "maintainability" (simplicity") and therefore age or "last commit" matter less. The average Clojure developer will first look into the code of the repository and make the choice to use it based on the code quality. That the project/library hasn't changed the last year or two matters less and might even be a sign of maturity, that the library is "done" so to say.

As a ex-JavaScript developer (together with many other languages) and now full-time Clojure(Script) developer since a couple of years back, I can only say that the community and ecosystem is more alive than ever, and there is no shortage of either jobs or candidates when you're either looking for work or looking to hire Clojure developers.

Yes, the pay is way more as a Clojure developer, which also means a typical Clojure developer is more expensive to hire than say a JavaScript developer. But for projects where I usually had to hire 2-3 JavaScript developers to hit any sort of interesting development velocity, I find it enough to just hire another Clojure contributor to really hit the ground running.

The real value in writing and maintaining Clojure programs is developer ergonomics. There is no other language that hits as many points as Clojure when it comes to make it simple to write efficient and easy to understand programs. Having your editor connected to a REPL and being able to send code back/forward between the running state of your entire program is such a super power that it's hard to write anything else than Clojure after you've gotten used to it.

However, biggest drawback is that you're gonna have to deal with the JVM sooner or later. When I first dove into Clojure, I had no idea about the Java nor JVM ecosystem, at all, so in the beginning, it took some getting used to the whole thing. But, you don't really have to touch Java the language, mostly details around the JVM, and there is a lot of documentation/material around understanding the JVM, so it's not hard per se.

Overall, before I discovered Clojure programming was mundane and I owe the fun in programming to Clojure wholesale. Now it's hard to do anything else but Clojure. But I'd still recommend anyone curious about functional programming, live editing of programs and lisps in general to give it a serious try. I probably wouldn't be programming anymore if it wasn't for Clojure. That I get paid more than my peers because I do Clojure/Script is just another point for the language, but that's not the main point for me at all.

Even in the most naive models your "market value" is based off Demand (how many jobs) AND supply (how many people can do the job), you need to be concerned about the ratio, not one side or the other.

If Pytyon has 100 jobs and 100 people then the ratio is 1 If Clojure has 10 jobs and 5 people then the ration is 2 and Clojure has a healthier market for you then python.

This is why it's a bad idea to evaluate software technologies entirely by what shows up in the social media hype cycle news. The only metric you learn from that is "what's the new fad that I can get attention by writing about because people are eager to form an opinion about this brand new thing".

Probably a much better idea to not choose a language at the "tons of posts about it" phase of the lifecycle. Pick something that enough people actually use that it is considered too boring to be the hot new thing.

Here is the Google Trends Comparison of Clojure, F#, Rust and Scala.

https://trends.google.com/trends/explore?geo=IN&q=%2Fm%2F03y...

Rust is 4-5 times more popular in searches that Clojure and F#. Interestingly Scala is around 3 times more popular than Rust in searches.

I don't think it's dead. I am learning it, getting a lot of help from community. It's the best programming language I have seen.

Typescript, Python, Kotlin, C#, Rust, Swift, Go. In that order, these are the >1% marketshare langs for new projects that aren't maintenance-mode in the next decade.

Depends on how you judge a language's "liveliness". Hacker surveys or job postings?

In Sydney, Australia C# and Java have the greatest number of job listings.

I would not say it is dead at all.

There are still Clojure jobs and new companies using Clojure.

It is a niche language, and I think it will stay a niche language, but that is fine.

C'mon. Just try a function. It's on me, no charge.

*procrastinates working @ his clojure job to browse hn*

Kotlin + Arrow is what you are looking for.

Dead, too many parentheses.

Closure is weird if you’re not already into lisps (I know, I know our fathers’ parentheses). It’s not easy to just pick up and start solving problems, because everything feels foreign.

I don’t know if it’s dead or not, as I’m sure people still love to use it… it just doesn’t have any major upside that’d make me want to adopt it.

Rust, as you’ve mentioned, is the opposite… huge upside out of the box and easy to adopt, so no surprise it’s getting more talk these days.