[ithrow]

That's a very common scenario for Clojure users to go through and it's one of the reason it has so many abandoned/unfinished libraries (although 7 years was a lot). After they have gather all the insights they can from Clojure and its ecosystem (which is a worthy endeavor IMO), they go back to their big ecosystem mainstream programming language because of all the benefits you get from it even if that programming language is worse. It also doesn't help Clojure the fact that JS 2020 is way better than JS in 2010 and that you can easily bring all your Clojure insights/concepts to JS.

[raspasov]

I have the opposite experience.

Every time I need to use another language outside of Clojure, it feels like most other languages are... confused. A bad case of "designed by committee" experience.

[dcolkitt]

> After they have gather all the insights they can from Clojure and its ecosystem (which is a worthy endeavor IMO)

Just out of curiosity, what do you mean by this? I've never used Clojure, but have done a fair bit of hacking in other Lisp dialects. Do you (or anyone with an opinion) think there's some insight benefit to Clojure specifically vis-a-vis Racket/Scheme/etc?

[ithrow]

Production implementations of persistent data structures in an industrial VM plus abstractions for state management, polymorphism, concurrency, the sequence abstraction, etc... It just gives more things for day-to-day programming. While Scheme gives you good foundations, you have to build a lot stuff yourself, it's too primitive (haven't follow Scheme since R5RS). But it's really mostly about the literal data structures and leveraging them anywhere you can to represent information, it's maps everywhere. Data oriented solutions is the common term use in the community. This answer by one the Clojure maintainers sums it up better than me: https://news.ycombinator.com/item?id=25377022

Racket extends Scheme with useful stuff too for everyday programming but Clojure's immutable data structures with its big library of functions for manipulating them in a nice abstract generic way, with the fact that in runs in the JVM gives it a big edge for "real world" programming IMO. You do need strong knowledge of Java and the JVM for critical services.

Almost all your knowledge of Racket and Scheme will transfer and be valuable for Clojure, so you already know most of it and have a big head start if you plan to learn it.

[divs1210]

Some of the top reasons for me:

* immutability with persistent data structures

* csp with core.async

* encourages designing a data-driven functional core with an imperative shell

* powerful REPL (better than python / scheme / racket, worse than SBCL)

* multi-platform (backend / browser / mobile through react native)

* easy and comprehensive testing because of several factors: functional nature, dynamic binding of vars, generative testing, etc.

[reader_mode]

Also one of the amazing aspects of JS ecosystem is TypeScript - structural type system on top of an open object system is such a flexible and pragmatic tool it's amazing.

Last time I used Clojure (probably 5 years ago to be honest) the lack of static typing combined with the functional nature made complex imperative code (which you're sometime forced to write, and there are examples of such code in standard library) almost impenetrable.