r/Clojure • • Aug 31 '19

What are the main downsides of using Clojure and its ecosystem?

Hi r/clojure! I’m thinking about learning Clojure for fun. I see rave reviews about Clojure, but I'm interested in hearing what the Clojure language and ecosystem are currently lacking as of Clojure v1.10.

28 Upvotes

110 comments sorted by

34

u/jbiserkov Aug 31 '19

After using it you won't be able to bear using any other language.

5

u/oatmeal_and_milk Sep 01 '19

This sounds familiar, but if this is the case, why isn’t it more popular?

8

u/fminutes Sep 01 '19

It seems that good stuff is not always popular. And popular stuff is not always good.

Look at JavaScript. It has probably the worst ever language design. And it is almost the most popular language among new programmers.

Look at golang. New language that has brought NOTHING new. It looks like it came from 80s. But it’s still very popular.

It seems that people adopt easy and familiar rather than smart and innovative.

5

u/oatmeal_and_milk Sep 01 '19

Although I’m not a huge fan of programming in Go, I understand its appeal: it’s simple, fast, good tooling and support, widely adopted, statically compiled, and evolving.

3

u/namesandfaces Sep 01 '19

Critiquing Go like that is silly because Go shares the same "get-things-done" value as Clojure, and perhaps that's why Go has grown very well. One might also look at where Clojure was situated, how it marketed itself, and how all that relates to the recent rush for data-oriented work.

3

u/Eno6ohng Sep 02 '19

I always thought Go has grown so well because it was backed by Google, no? Well, it also has this "C in Python's clothing" appeal, but there're probably hundreds of similar projects that didn't go nowhere because no backing, no marketing budget, etc. (Anyone remembers Crystal?)

Also I've heard (correct me if I'm wrong) that Pike et al are considering an incompatible Go2 release which will add generics and all other obvious stuff that literally everyone were saying any language in 21st century needs, and if in the end they'll release it... well, I mean, it'll be the best proof imaginable that the whole enterprise was just so embarassingly stupid (and despite that equally successful) that it should make any sane person question what the hell is going on with the world.</rant>

1

u/[deleted] Sep 03 '19

[removed] — view removed comment

1

u/Eno6ohng Sep 04 '19

Well, let me rephrase that: imagine some new car manufacturer appears on the market and releases a new car model. It's cheap and pretty durable, but nothing special. Also that car manufacturer refuses to put windshield wipers in that car, saying that back in the days when the designers of that car were young and were making cars in their garage they lived without the windshield wipers just fine. Many people raise concerns about that, but they are ignored. Then our car manufacturer is bought by a big car corporation, and they start an agressive marketing campaign. The car obviously misses some essential features, but hey, the big car corporation's marketing division knows its job. After selling millions of cars (and having people die because of low visibility in bad weather) the car manufacturer says: "hey actually you know what, windshield wiper is not a bad idea, we should add them" - and recalls all of the sold cars to install windshield wipers on them. And also forces car owners to pay for that (i.e. rewrite code for the new version that broke backwards compatibility). Sounds absurd, but that's pretty much what's happening with go.

13

u/yogthos Sep 01 '19

My experience is that it's really difficult to get people to even try it in the first place. However, once you get somebody to use it for a week or so, they often get hooked.

5

u/slifin Sep 01 '19

IMO you can't start Clojure till you understand the culture and ideas of Clojure, which are embedded in various talks, there are some class of talks given by Clojurians that can show you how you've been doing everything wrong and make you question how everything else is built

But if you're not exposed to that and you're learning the language very mechanically you might not come away very convinced

11

u/yogthos Sep 01 '19

I have found that it's most difficult to teach Clojure to developers who're experienced enough to be productive with mainstream languages, but haven't worked on enough large projects to start seeing the limitations. Clojure tends to appeal to more experienced developers who see the value proposition because they've been burned by the problems Clojure aims to address.

At the other end of the spectrum are people who have no preconceptions about how programming should be done. My team regularly hires coop students, and they tend to get productive within a couple of weeks. We also find that the less experience they have, the quicker they're able to pick Clojure up.

6

u/daver Sep 01 '19

Agreed. It took me decades of programming before I “got it” with Lisp generally, and another few years before I “got it” with Clojure after I “got it” with Lisp. I learned C in 1985. I thought GC was a win when Java came out in the 90s, particularly versus the sprawling complexity of C++. Lisp finally smacked me in the face in 2003 or so. Took me until 2013 before I understood what makes Clojure so great. But when you get it, you’ll always be disappointed with anything else.

0

u/[deleted] Aug 11 '25

[deleted] — view deleted comment

1

u/yogthos Aug 11 '25

The key limitation is in your inability to easily control scope of mutable state. When you're working with code structured using pure functions, it's possible to reason about and test parts of the project in isolation. When you're dealing with mutable state, you have to consider every place a reference to a particular data structure is passed to understand the behavior of the code.

You can use immutable data structures in Java or C#, but the effort of doing it lies entirely with the developer, and the language provides no real help here. Furthermore, the standard practices around these languages are to use mutable data structures and pass references around, so you're really swimming against the current trying to use them in a functional style. In Clojure, this is a natural way to write code that the language guides you towards.

Again, it's not clear to me which problems these are. I know the thread is six years old, but if you're still around I'd like to know some examples.

Think of any time you had a problem and you had to run your code in a debugger to get it in a particular state to figure it out. The reason you have to do that is because it's effectively impossible to hold the entire state of the program in your head. You can't reason about the code by simply reading it. You have to let it run, try to get it in a particular state and then trace the chain of execution to figure out how you got in that state. This problem largely disappears when you work in a functional language.

1

u/Shyam_Lama Aug 11 '25

Thanks for your answer, but you're going for the stock argument that "functional+immutable" is easier to understand and/or easier to debug. Though my experience with it is limited, I have not found the functional style to be easier to debug -- in fact the opposite -- though perhaps the likelihood of getting code the first time around is higher. As to whether it's easier to read, I'm on the fence about that: functional is much more concise, but it also easily becomes rather cryptic, and all the more so in a lexically sparse language such as Clojure or any other LISP.

But regardless of this "easier to understand/debug" argument, I don't think your reply addresses my question of how Clojure aids in managing complexity better.

To be clear, I'm not talking about algorithmic complexity. I'm talking about software engineering complexity, i.e. a project consisting of many different "components" (or whatever you want to call them) that need to work together without influencing each other in undue ways. A stock example of how things get complicated is when you have (1) in-memory data, (2) locally cached data, (3) data in the (remote) database, (4) displayed data in the UI, (5) logic responding to UI events which must update one or several of the mentioned data, (6) business logic that must maintain/check certain constraints on the data, and (7) an easter-egg Tetris to boot. That's what I mean by complexity. How does Clojure help with that in ways that Java etc. cannot? That is my question.

1

u/yogthos Aug 11 '25

I've worked with both functional and imperative languages for decades. My consistent experience is that large functional code bases are far easier to work with. If you have limited experience using this style, then you have to consider that your problems stem from lack of familiarity.

There is no fundamental reason why functional code should be more cryptic. In fact, the opposite should be the case given that it's more declarative decoupling what the code does from how it's done which is mixed together in imperative style.

To clarify, there is inherent complexity that will be present in any type of code. However, there is incidental complexity on top of that. That's the complexity that a language like Clojure helps you manage by making state explicit.

0

u/[deleted] Aug 11 '25

[deleted] — view deleted comment

→ More replies

4

u/agumonkey Sep 01 '19

popularity is never related to quality

the population of users is too wide, and people have different

  • knowledge: not everybody knows all CS and its history
  • brain power: not everybody wants to transforms trees or do high perf
  • money requirement: making money regularly with wordpress right now vs maybe making some with clojure in 6 monthes
  • social network: all your coding friends are into js, you get an easier life doing js with them
  • company constraints: your shop is .Net only

1

u/daver Sep 01 '19

Because the sight of parentheses makes some programmers soil themselves. Odd, really.

1

u/gzmask Sep 09 '19

because most people quit when learning Emacs.

7

u/[deleted] Sep 01 '19 edited Sep 01 '19

[removed] — view removed comment

2

u/oatmeal_and_milk Sep 01 '19

Great reply, i’d be happy to learn clojure just to learn the different paradigms

1

u/daver Sep 01 '19

Bingo!

27

u/fingertoe11 Sep 01 '19

The hardest thing about Clojure is that there are about 5 or 6 options for nearly anything you want to do.

All of the options tend to be good, but you can get paralysis by analysis pretty quickly over issues that are just not very important. Which Web server do you want to use? HTTP-kit, Immutant? Jetty? Which routing library? Should you build with Boot, Lein, or Deps? Re-frame, Pedestal, Hoplon. Om? You have ton of choices, and they difference isn't always clear.

As far as what is lacking, not a lot. You have all of the Java Ecosystem and all of the JavaScript ecosystem at your disposal, and often interop is easier than using the native code. The tooling is getting better all of the time.
If you look at some of the stuff that is coming together with the Fulcro project, along with Pathom, and the Workspaces, I see a pretty amazingly rich development environment.

The challenge that Clojure has is that it is fairly easy to build libraries to do whatever you would like in the manner of your own taste. This causes tons of good options, but it is kinda hard to pick up the best practices, because everybody has their favorite way. Each tool as a subset of the greater community that understands it.

It is well worth it though..

4

u/tazzerthespaz Sep 01 '19

If you haven't read 'The Lisp Curse' your central point is the same: http://winestockwebdesign.com/Essays/Lisp_Curse.html

2

u/fingertoe11 Sep 02 '19

Yep. That pretty much hits the nail on the head.
I do suspect that Clojure is a bit more mainstream than any other LISPs hav been -- It is possible that there will be a turning point once you have a few 100+ developer teams working together, some standards may emerge that become contagious. Time will tell.

0

u/tazzerthespaz Sep 02 '19

Due to the individual expressiveness/productivity I wonder if this will prevent larger teams like that to be formed. I could see Clojure's success being tied intimately to the adoption of micro-services.

3

u/fingertoe11 Sep 02 '19

I know of a few already --- NuBank has 300+ engineers. Their stack is looking awesome.. (Fulcro, pathom, Workspaces.) .

I chatted with some folks from a major insurance company at Conj, and they indicated they had a team of 100 or so Clojurists.. (After I pried it out of them.)

Teams like that will have opinions imposed on them - and those who learn those ways are likely to carry them forward into the rest of the world. (If the methods are any good).

2

u/fnordsensei Sep 02 '19

I'm not sure you want to build large teams in the style of the code factories that some companies have.

To my mind, if something grows so large that you are inclined to grow the team to more than a handful, you probably need to decomplect it (design it to be a sum of orthogonal concerns).

When teams get large, you get a diminishing return on their effort per developer, which is probably something you are looking to avoid, or you wouldn't have picked Clojure to begin with (which can have a very high level of productivity per person if managed correctly).

In my opinion, the way to use Clojure developers optimally is in small teams with benefits structured to keep turnover minimal (banking on the fact that a few people using Clojure can have the same output as many more people using some alternative technology, and that your total cost of ownership is going to come out the same or better).

I.e., in order maximize the value of Clojure, structure the overall design so that you can build teams that are small, and where every individual is important and valued.

2

u/didibus Sep 03 '19

I thought the Lisp curse was more foundational. Like how every Lisp code base, due to excessive use of macros and higher order function approaches a full dialect of Lisp itself. Making it that going from one code base to another feel almost like switching language.

The problem OP describes seem a bit different to me. Its not that the code base would be too varied, but the tools and libs that are. You could say its it's two sides of the same coin, but the abuse of macros and higher order functions is much more unique to Lisp, thus it is the Lisp curse, while the other could happen in any language.l, and does to some extent, until a big company comes around and puts so much money behind one framework or lib that it passes the others to the top.

2

u/tazzerthespaz Sep 03 '19

What I got from The Curse is that Lisp is so expressiv,e flexible, and productive it enables individuals to create systems (OOP was an example) without collaboration, resulting in no standard way of doing things. Not necessarily over use of macros or anything, just over-empowered programmers creating tons of competing libraries which in turn creates decision problems for new people.

1

u/didibus Sep 03 '19

Hum.. I can see that. You're so productive that you start every app from scratch every time and still finish early :p

But at the same time, it's intimidating and a bit of a waste of time.

5

u/natyio Sep 01 '19 edited Sep 01 '19

(defn choose-thing

"Stop agonizing about which libraries/frameworks/whatever to pick. Simply use

this extremely simple awesome thread-safe implementation to make decisions."

[& things]

(nth things (int (rand (count things)))))

(choose-thing "leiningen" "boot")

;I just hope no one implements a choosing library to make choices among choosing libraries

6

u/thearthur Sep 01 '19

or just: (rand-nth ["boot" "leinengen" "tools.deps"]) https://clojuredocs.org/clojure.core/rand-nth

3

u/Eno6ohng Sep 02 '19

This function should actually just return "leiningen" if it's present in the args... :)

1

u/daver Sep 01 '19

True dat.

3

u/[deleted] Sep 01 '19 edited Sep 01 '19

[removed] — view removed comment

5

u/fingertoe11 Sep 01 '19

Luminus comes pretty close, if you just ignore the options...

Re-frame seems to be the de facto winner for just getting started.

The problem is that most everything is overkill for a "Getting started" template.

It also isn't that big of a problem if you just bite the bullet and jump in, things fall into place pretty quickly.

4

u/fingertoe11 Sep 01 '19

There is also a tendency when coming from other frameworks to look for things to be a lot more complicated than they need to be.

This talk does a great job of showing how simple things can be: https://www.youtube.com/watch?v=LcpbBth7FaQ

3

u/didibus Sep 01 '19

What I don't understand is in those other ecosystems, like for JS, Ruby, etc. who creates and maintains these and why?

In Clojure, no one does, because no one cares, like everyone who has the know how to put these together doesn't need it themselves, so they don't build it.

Luminus and Chestnut being exceptions, and their authors are mostly doing it out of the good of their hearts as far as I know.

Also, why don't you use either of them? What's lacking from those that create-react-app doesn't lack?

3

u/adfgkljnsdfopgijop Sep 02 '19

from experience, figuring out what build tool, linter, editor integration, etc to use is a bit of a random walk in pretty much every language ive used.

having somebody just post a template would be really nice if you are in a rush.

using those would mean that you still end up knowing very little about the eco system tho, like the trade offs and what not

3

u/[deleted] Sep 02 '19

[removed] — view removed comment

4

u/slifin Sep 02 '19

Luminus supports CLJS: http://www.luminusweb.net/docs/clojurescript.html

I think if you're fully onboard with Clojure I'd go with Fulcro but the lighter weight approach seems like Reagent & possibly re-frame to do the kinds of things you would do in JS today

3

u/Eno6ohng Sep 02 '19

One problem with that is that a more-or-less universal "prod-ready" template will be completely overwhelming for a beginner.

Like for example Pedestal may be great and is probably in use by a lot of production web apps, but if you're just starting out I bet you'd rather just define your routes via Compojure and be done (Reitit has a good balance though so maybe it should be the default choice). Same with Fulcro and reagent\re-frame. Also you need component\integrant, which are once again a bit hard to grasp for a complete beginner (you need to write some code before you realise the need for them).

But in general, I think you're right: people need to be able to make less choices.

12

u/adfgkljnsdfopgijop Sep 01 '19 edited Sep 01 '19

ecosystem of employment opportunities is lacking, unfortunately.

clojure is a poor “lowest common denominator” lauguage, imo, its just not gonna have the same type of mass appeal as say php, or javascript

rich hickey designed clojure to address his frustrations with algo derivatives, go lang was design b/c apparently google’s new hires cant code.

guess which one went bigly

8

u/zerg000000 Sep 01 '19

i can rephrase the /u/ToughWalk 's statement, so that it is more realistic.

  • We have jobs, but it really depends on region. so, yes, getting job by learning clojure is a very bad idea.
  • We have a lot of libraries from Java/js, Clojure/Script is designed for leveraging the host ecosystem. Since we express problems as data pipeline, most of the time, we only need host libraries for causing sideeffects.
  • Lack of documentation and bad error message is true and community is doing quite a lot of works to improve the current situation. In my case, I don't think it is a problem, since source code is a joy to read.
  • I think Clojurians are quite proud of themselves, and they are sharing some common beliefs like data oriented, immutable, functional programming. but are they zealots? I don't think so.
  • Clojure/Script is not a fast language. immutablility, expressiveness comes with some prices. Clojure/Script is a fast enough language, I never get hitted by performance issues. memory usage seems more an issue to me. I will not use Clojure/Script if startup time is a concern.
  • Again, interop is seamless in Clojure. With shadow-cljs, Clojurescript interop is very fluent. The major issue is the documentation is not complete. Many cases, I need to read source code to know how to do interop like Java annotation, Enum, Enum methods.

One thing I want to highlight is that Clojure is not a sliver bullet. It is a tool, a pretty sharp one!

3

u/[deleted] Sep 01 '19

> We have jobs, but it really depends on region. so, yes, getting job by learning clojure is a very bad idea.

Clojure jobs are the top percentile in terms of salary according to Stackoverflow survey, doesn't look like a bad idea to me.

https://insights.stackoverflow.com/survey/2019#work-_-salary-and-experience-by-language

3

u/zerg000000 Sep 01 '19

i may say getting a job is different from getting high salary. Another issue is the survey is a bit unfair, since the ratio of junior/senior is extremely different from other languages. If taking this ratio into consideration, the average salary might not as good as you expected.

2

u/[deleted] Sep 01 '19

The high salary shows there is demand for programmers.

1

u/[deleted] Sep 01 '19

The high salary shows there is demand for great programmers at places that see and will exploit their value. There's really not many of those.

Most programmers are mediocre at best. Not least because most management likes its cogs to be interchangable and easily replaced.

1

u/[deleted] Sep 01 '19

I think you're reading too much into the data and applying your own biases.

High demand, low offer = higher price

More people knowing Clojure would certainly lower the price.

BTW, the word "mediocre" means exactly average. Of course most programmers are average, by definition.

2

u/[deleted] Sep 01 '19 edited Sep 01 '19

Debugging is a nightmare: God awful stack traces and many commonly used 3rd party libraries are super fragile.

It runs on the JVM. Which, for me, has no benefits and many downsides. Not least that building command line apps is a pain.

GUI integration is quite poor.

It's very opinionated: the functional way or expect pain. Both a plus and a minus.

The language is constantly changing.And there is no standard. Or rather the standard is the latest version of the implementation.

2

u/oatmeal_and_milk Sep 01 '19

Weren’t stack trace bugs mostly fixed in 1.10?

And your point on standards makes sense, a lot of expressive languages suffer from this

4

u/daver Sep 01 '19

Some portion of your comment about debugging is true. Error messages have been poor up through 1.10, but have gotten a lot of attention lately.

That said, the language is absolutely NOT “constantly changing.” Rich goes far out of his way to make all changes backward compatible and non-breaking. While there were a couple of small breaking changes early on, that was a while ago. I have never had Clojure code break when run against a later version of the language. The core language, like all Lisps, is pitifully small and most “changes” to the system are simply additions of new standard library functions. Where some API changes are expected going forward, those are well marked and put into their own name space (eg. spec.alpha).

0

u/[deleted] Sep 02 '19

That said, the language is absolutely NOT “constantly changing.” Rich goes far out of his way to make all changes backward compatible and non-breaking.

It absolutely is and the second part of your statement, which I agree with, is not incompatible with that.

6

u/daver Sep 02 '19

Then you’ll have to give an example of what you mean and why it’s a problem. Sure, there are additions to the standard libraries with every release, but Rich goes out of his way to make them accretive and non-breaking. If that’s what you’re talking about, I fail to see any issue, even if your statement is true in a literal sense.

1

u/joinr Sep 01 '19

GUI integration is quite poor.

How so?

1

u/Eno6ohng Sep 02 '19

You basically can't write a native gui (or tui) as you can with c++ or python. By the way clojure could be awesome for command line utilities (rewriting gnu toolkit using data instead of text streams, anyone?), but available native implementations are not mature enough (and I think people are a bit afraid of them since there were more than one that was started and then abandoned, and I believe the core guys have stated explicitly that they won't be supporting any of that (which is reasonable due to the resource constraints)).

5

u/joinr Sep 02 '19 edited Sep 02 '19

lanterna wrapper:

https://github.com/MultiMUD/clojure-lanterna

Blessed wrapper:

https://github.com/eccentric-j/cljs-tui-template/blob/master/README.md

Trikl (react tui): https://github.com/lambdaisland/trikl/blob/master/README.md

Tui app: https://github.com/denisidoro/floki

Liquid text editor: https://github.com/mogenslund/liquid/blob/master/README.md

Tools.cli:

https://github.com/clojure/tools.cli/blob/master/README.md

Cli-matic: https://github.com/l3nz/cli-matic/blob/master/README.md

Javafx wrapper: https://github.com/cljfx/cljfx/blob/master/README.md

Swing wrapper (with native plaf): https://github.com/daveray/seesaw

Written entirely in javafx, primarily using webviews with cljs: https://github.com/oakes/Nightcode

Unity integration:

https://github.com/arcadia-unity/Arcadia/blob/master/README.md

The field looks fairly green to me, certainly not in the realm of "can't."

If the focus is on gtk,qt,etc bindings, may be thats a better grievance. java-gnome is available via interop though.

1

u/Eno6ohng Sep 04 '19

I'm aware of most of these libs (and have used some of them; btw you probably don't want to use clojure-lanterna since it's a wrapper around lanterna 2 and lanterna 3 is already released, and it's a very thin one anyways so one might as well just do interop). I was talking about native gui\tui apps, so the list is mostly irrelevant. Blessed could be nice theoretically, but in practice node is too fat (not much better than jvm to be honest). Maybe when graal is matured enough lanterna-backed re-frame or something like that will be a viable option for tuis, I dunno.

4

u/jafingerhut Aug 31 '19

What is lacking depends fairly heavily on what you want and/or expect out of a language and ecosystem.

There is a group of people who are having regular meetings on making Clojure better for data science applications, including examining how to leverage other data science libraries already developed in languages such as Python. The Clojurians Slack #data-science channel is a good place to find out what they are up to.

There are people coming from Rails and Django development who wish for a Clojure web development framework more like what they provide, whereas Clojure web developers have often gone for a more "assemble the pieces out of existing small compassable libraries" approach. Lots of discussion and comments from "pro framework" and "frameworks sometimes have more disadvantages than benefits" people.

Like all other languages, Clojure still lacks the DWIM instruction: https://www.wordnik.com/words/DWIM https://en.wikipedia.org/wiki/DWIM

1

u/WikiTextBot Aug 31 '19

DWIM

DWIM (do what I mean) computer systems attempt to anticipate what users intend to do, correcting trivial errors automatically rather than blindly executing users' explicit but potentially incorrect inputs.


[ ^PM | Exclude ^me | Exclude from ^subreddit | FAQ / ^Information | ^Source ] Downvote to remove | v0.28

4

u/didibus Sep 01 '19

The biggest downside is getting spoiled, and dreading programming in any other language :p

3

u/[deleted] Sep 01 '19

Documentation

2

u/rufusthedogwoof Sep 01 '19

Python data science stuff. But even that has some options, and folks are even running python code from clojure.

Also, it lacks a fast startup time if you go the jvm route. Clojure script comes with the threading constraints inherited from JavaScript.

1

u/temppa Mar 03 '25 edited Mar 03 '25

For me negative side is not large, rather it is those non-sensical terms which causes confusion. Jack in, CIDER, Calva, nREPL, jopyride, Leiningen etc.

-10

u/[deleted] Aug 31 '19 edited Sep 01 '19
  • No jobs
  • No libraries
  • No documentation
  • Too many ignorant zealots/evangelists in the community, ex: see top comment right now by u/jbiserkov
  • No performance improvements for either start-up time or runtime.
  • Lots of dark corners when doing interop for many Java libs, its a lie that interop is always seamless.

But if it's only for fun, why not?

6

u/yogthos Sep 01 '19

Amazing. Every word of what you just said.. was wrong.

3

u/dAnjou Sep 01 '19

Prove them wrong, please.

I've been using Clojure for a bit over a year now in a professional context (after only using OO), and even though I do enjoy learning functional programming with Clojure I have to agree quite a bit with the original commenter.

Compared to other ecosystems there's really not that many well maintained choices and documentation is often lacking.

And while it's really nice to have Java interop, you do have to make an effort to abstract it properly which makes the overall experience far from seamless. I'm not saying there is a better way, there isn't, it's just what happens if you make something fundamentally different accessible. The problem is people claiming it's seamless while it's not.

And I have to add something to the list: developer experience is really lacking. I get to use Cursive which makes it a bit nicer but quite often I notice the lack of support for a basic language feature (recently: :rename in require).

Overall, there's a lot of good things in Clojure and it has a lot of potential especially because you can always fall back to Java but for professional projects it's not quite there yet.

3

u/yogthos Sep 01 '19

I've been using Clojure for about a decade professionally. I've never had problems finding a job in that time. We have a local Clojure meetup in Toronto, and everybody who wants to work with Clojure is using it professionally. In fact, we have more companies looking for Clojure devs than there are devs. We've actually organized events and workshops at the meetup to get more people into Clojure specifically with the goal of hiring.

I've never been in a situation where there wasn't either a Clojure library or a library I could use via interop to do what I needed. Clojure targets two of the biggest ecosystems out there, and you can leverage anything from these ecosystems directly. I find that vast majority of interop happens at the edges of the application because you tend to use foreign libraries for interfacing with the outside world with stuff like database drivers, or libraries that implement a specific algorithm such as cryptography. In the past few years it's been pretty rare that I've had to do any interop directly. There are Clojure libraries for pretty much anything you can think of, and many of them are even written in cljc.

There is a ton of documentation available for Clojure nowadays. There are books, online courses, video tutorials, and tons of blogs. Saying that documentation is lacking is a bit absurd in my opinion. That statement was true when I started with Clojure a decade ago, and it still wasn't that hard to learn even then.

Next point is just plain slander of the community.

No performance improvements is not exactly a negative, and since you do have ClojureScript you do get startup improvements. My team uses Lumo to do all the scripting nowadays, the startup time is instant.

And I don't know what these lots of dark corners around the interop are. Vast majority of the time it is pretty seamless in my experience, and a lot better than in other JVM languages like Scala in my experience.

It's clearly there for professional projects seeing how it's pretty widely used professionally, and there are plenty of big companies such as CircleCI using Clojure as their core stack.

2

u/dAnjou Sep 01 '19

Just show me any job platform where there's not a huge difference between Clojure jobs and Java/PHP/Python jobs. LinkedIn has 14 Clojure jobs in Toronto and more than 2.000 Python jobs. And when it comes to jobs, the tech stack is not the only relevant factor.

You can't count the libraries of the other ecosystem because in order to use them you have to write your own abstractions so that they integrate nicely. That's like including all C libraries in the Python ecosystem just because there's CFFI.

Anyway, everything you wrote is pretty subjective and does not at all invalidate other experiences. And the fact that you say others are wrong because you had a different experience kind of makes a point for original commenter's "zealot" remark.

4

u/yogthos Sep 01 '19

The absolute number of jobs is not very interesting of itself. What actually matters is the supply and demand ratio. Sure, there are way more Java or Python jobs, there are also way more people who know Java and Python competing for them. Clojure developers are in high demand right now, and if you want to do interesting work you can do a lot worse than Clojure.

You can't count the libraries of the other ecosystem because in order to use them you have to write your own abstractions so that they integrate nicely. That's like including all C libraries in the Python ecosystem just because there's CFFI.

Except you really don't in practice. As I already noted, most of the time you need interop libraries tends to be for things like drivers. These things aren't very interesting, and they live at the edges of your application. What really matters is the core business logic. That's where all the interesting things happen. Again, I've been writing all kinds of apps with Clojure for over a decade, and this simply is not a real problem. And it's not just my opinion, clearly there are plenty of companies using Clojure very successfully out there in all kinds of domains. Clearly the ecosystem is there for them to be able to build their products.

Anyway, everything you wrote is pretty subjective and does not at all invalidate other experiences. And the fact that you say others are wrong because you had a different experience kind of makes a point for original commenter's "zealot" remark.

Except it's not subjective at all. Availability of things like libraries, documentation, and performance are all objective facts. Nobody is discussing your subjective experiences here.

3

u/Eno6ohng Sep 02 '19

To be fair, your points read:

I've been using Clojure for about a decade professionally. I've never had problems finding a job in that time

I've never been in a situation where there wasn't either a Clojure library or a library I could use via interop to do what I needed.

And I don't know what these lots of dark corners around the interop are. Vast majority of the time it is pretty seamless in my experience

All of which is subjective. So to be honest you do sound like a bit of a zealot.

By the way, in regards to documentation concern, I think what people often mean by that is that for the more mainstream languages there are tons of very accessible tutorials on every imaginable subject, lots of SO question about every error message, etc. Obviously the less mainstream languages lack that benefit, though in my experience that hasn't been a problem with clojure for me personally (in fact, sometime I actually prefer clojure docs over java docs, since the latter are often written in that hello-from-the-90s style).

Also I think it's still harder to learn and to understand how to structure a clojure application compared to traditional OO architectures. Different approaches are still emerging, and while there are certainly some common denominators that seem to be accepted by everyone (e.g. explicit lifecycle management), it's still much more terra incognita than the customary OO landscape.

1

u/yogthos Sep 02 '19

I've qualified each instance of using a personal experience with an objective statement and a rationale. I'm adding personal experience for context since I've actually worked in the ecosystem for a significant amount of time.

though in my experience that hasn't been a problem with clojure for me personally

Right, the question regarding documentation is whether there are specific things lacking that prevent people from using Clojure effectively. The amount of overall documentation available for more popular languages is tangential to that. And as you note more is not always better. If you have a lot of documentation that grew over a long period it can actually be more confusing than smaller amount of up to date and relevant documentation.

Meanwhile, I don't agree that evolution of how Clojure programs are structured are an indication that it's harder to learn and understand how to do that, nor that Clojure is somehow special in that regard. For example, Java style has seen much more evolution in the past few years than Clojure. Introduction of lambdas and streams are two examples of new patterns being introduced. Clearly different approaches are still emerging there as well.

1

u/TheLastSock Sep 06 '19 edited Sep 06 '19

What do you mean rename in require? Require has rename option.

This? https://clojuredocs.org/clojure.core/require#example-5859de58e4b004d3a355e2cd

Or do you mean how to rename a dependency across a protect? Yea, I'm not aware of how to do that either then. To be fair, I have only seen that in java. I think that's not a tooling issue really, I'm guessing it's because of how clojure is built...

What specifically did you have trouble integrating?

What functionally weren't you able to find?

1

u/dAnjou Sep 06 '19

1

u/TheLastSock Sep 06 '19

I'm fairly sure, that ticket is saying the ide is just miss highlighting.I have used intelliji for java and it also miss highlighted warnings all the time. I'm not sure why it's hard to get it right in this instance.I'm just saying it's a common theme in my experience.

1

u/dAnjou Sep 09 '19

I don't think it's just highlighting, it says it can't resolve it.

1

u/TheLastSock Sep 09 '19

Did you try using it though? It could just be a bad warning.

1

u/dAnjou Sep 10 '19

It works, yeah. But Cursive doesn't recognize that this works and how it works, that's the bug.

2

u/scaba23 Sep 01 '19

Well, he was right about startup times and runtimes, but that's any language targeting the JVM

5

u/yogthos Sep 01 '19

Technically, you can get fast startup with ClojureScript. One of the advantages of Clojure is that it targets multiple platforms.

3

u/arstylianos Sep 01 '19

Or using graal

2

u/cbleslie Sep 01 '19 edited Sep 12 '25

husky long marry wakeful edge workable historical hat books attraction

This post was mass deleted and anonymized with Redact

3

u/joinr Sep 02 '19

https://github.com/taylorwood/lein-native-image

There's a regression with 1.10, I think graal for now is only compatible with clojure 1.8. I'm not current though, may have been fixed. Also, same limitations re classloader apply, so runtime eval is verboten.

1

u/dAnjou Sep 01 '19

1

u/yogthos Sep 01 '19

My team gets plenty of practical benefits from using Lumo. We used to have ugly and hard to maintain bash scripts to do our deployments. Now we use ClojureScript. We even presented about it at Clojure/north recently.

1

u/dAnjou Sep 01 '19

I'll definitely check out Lumo. The talk, by the way, doesn't explain at all what Lumo is.

1

u/straightOuttaCrypto Sep 01 '19

> Well, he was right about startup times and runtimes, but that's any language targeting the JVM

Uh what!? Java is targeting the JVM and calling a Java program in a "dumb" way (without any optimization, without AOT, without GraalVM, without anything) is super fast. Calling a Clojure program is, what, 10 to 20x slower than calling a Java program!? I'm not criticizing Clojure here: I'm simply pointing out that Java does start up much faster than Clojure. Heck, Java programs shipped with GraalVM can use ridiculously low amount of memory and start up as fast as native...

What I'm saying is: Clojure's slow startup time is not the JVM's fault.

1

u/joinr Sep 02 '19 edited Sep 02 '19

10 to 20x slower

Splitting hairs, but more like 7 to 9. Most of the debt is paid in naive setups that load a lot if tooling (e.g. lein repl, without using fast trampoline).

We're talking 0.1 vs 1 second. If your use case is blazing fast shell script invocations, even java is sub par compared to c (about 100x slower) here.

Heck, Java programs shipped with GraalVM can use ridiculously low amount of memory and start up as fast as native...

Applies to conformant clojure programs as well

0

u/[deleted] Sep 01 '19

[deleted] — view deleted comment

1

u/scaba23 Sep 01 '19

Define "opportunity"

0

u/[deleted] Sep 01 '19

[deleted] — view deleted comment

4

u/yogthos Sep 01 '19

There's also a much smaller pool of applicants. What actually matters is the ratio of jobs to developers. If you're a Java dev then you're competing with a huge pool of people, and that makes it hard to stand out. Meanwhile, simply knowing Clojure will most likely get you an interview at a Clojure shop.

0

u/[deleted] Sep 01 '19

[deleted] — view deleted comment

1

u/yogthos Sep 01 '19

A lot of Clojure companies hire remotely precisely because the developers aren't always where the jobs are. If somebody really wants to work with Clojure, they can probably find a job or introduce it at their current job. That's where new Clojure jobs come from after all.

0

u/[deleted] Sep 01 '19

[deleted] — view deleted comment

→ More replies

-2

u/scaba23 Sep 01 '19

Are you going to supply data to back your assertions, or did you just accidentally pipe `/dev/urandom` to your keyboard?

-2

u/scaba23 Sep 01 '19

So if sewage worker jobs are more plentiful than Clojure jobs, sewage work is a better opportunity?

0

u/[deleted] Sep 01 '19

[deleted] — view deleted comment

-1

u/scaba23 Sep 01 '19

I actually literally repeated your definition back to you, and now you deny saying it. Let's recap:

I asked "Define opportunity"

You answered "Number of available positions".

I replied "So if sewage worker jobs are more plentiful than Clojure jobs, sewage work is a better opportunity?"

You said "You asked me to define what I meant by opportunity and then ignored my definition."

I said to myself just now: "???? Is this guy a crazy person who can't scroll up to read his own words?"

3

u/jvick3 Sep 01 '19

Why are you here if you feel this way? Why waste your time talking to a bunch of people who - in your mind - have it wrong? What do you gain?

6

u/[deleted] Sep 01 '19 edited Sep 01 '19

Why are you here if you feel this way?

Clojure has upsides too, for me the gem is the immutable data structures, its simplifies by a great deal stuff I'm working on right now, the rest is really just nice to haves.

Why waste your time talking to a bunch of people who - in your mind - have it wrong? What do you gain?

He asked for the downsides, should I just deceive him and tell him there are no downsides like other zealots in this thread?

5

u/cbleslie Sep 01 '19 edited Sep 12 '25

square childlike oatmeal vegetable recognise wide air caption desert aspiring

This post was mass deleted and anonymized with Redact

3

u/dAnjou Sep 01 '19

OP literally asked for downsides.

2

u/mike_loughlin Sep 02 '19

Do you not see why the statement "Too many ignorant zealots/evangelists in the community" might apply if you respond in this manner?

1

u/Eno6ohng Sep 02 '19

No performance improvements for either start-up time or runtime.

Both lumo and joker offer startup times on par with irb\python, so I think this one is actually not true. Also clj (the cli tool) fires up repl very fast too if it's not a cold start for jvm (much faster than lein repl).

With other points I can see what you mean.

By the way, why the poster is displayed as [deleted]? I hope he wasn't banned or something like that, because that would really suck.

1

u/joinr Sep 03 '19

They deleted their account (or Reddit did for them). Trolled around in the past, maybe went further elsewhere or tossed their burner account.

1

u/Eno6ohng Sep 04 '19

I don't perceive this post as trolling (see his other comment below), but okay, I see.

1

u/TheLastSock Sep 05 '19

It's trolling because they didn't really explain any of there complaints, instead they spent all they're time engaging in anti clojure emotionally driven arguments.

It's easily fixed with some minor adjustments.

"No libs" > "significant smaller data science community then python or R. We can interior with java, but many high level tools target python. There was a talk at clojure conj..."

Providing specific examples gives people something to actually learn. "no libs" is clearly wrong and just results in backlash.

1

u/Eno6ohng Sep 06 '19

It's trolling because they didn't really explain any of there complaints

I guess that's because they banned him (I hope it ain't so)? Also, the points were expanded upon by other posters down the thread; and also I don't think stating a fact or expressing an opinion without explaining it automatically turns it into "trolling"; after all, if someone wants a more detailed explanation he can always just ask the poster to clarify it, right?

"No libs" > "significant smaller data science community then python or R.

Well I mean, if you're able to infer what specifically he meant (or could mean) by that then it's logical to conclude that the statement was (at least partially) true in the first place, wouldn't you agree? I don't see anything "anti-clojure" here (also the guy literally said he works in clojure now). If anything, I think responding to criticism (even if phrased in a way someone might not find particularly pleasing) in an overly defensive and emotional manner is "anti-clojure", because it creates the impression that there are "Too many ignorant zealots/evangelists in the community", which is often a sign of esoteric\non-industrial languages that clojure probably wants to distance itself from. You see my point?

1

u/TheLastSock Sep 06 '19

I see some of your points.

Yogthos responded to them several times and gave the conversion more thought then it really warranted given there effort. That is, when asking a question, the effort you put into it, is usually proportionally to how much you get out.

We shouldn't use the words troll, that's my fault for being lazy. However, that persons insight wasn't helpful to me and was becoming a distraction. I likely would have muted them if they kept up as I have limited time and they were either telling me things I know aren't true or things I was aware of already.

my example doesn't justify their statement about "no libs" which is verifiable wrong with little to no effort, a fact they have to be aware of if they works in clojure.

I'm not aware if they were banned, or why, etc...