Hacker News Reader

Comment by tigroferoce | Hacker News Reader

I also had the privilege to work with clojure for a couple of years on a large project. That was wonderful. Hands down the best language/framework/approach to development I’ve ever had. I still find crazy that it’s not one of the main programming language out there.

View on HN

Unfortunately, despite consistently hearing about how enjoyable Clojure is, I think many people are turned off by the JVM. This is probably also the problem with Scala, which is apparently also enjoyable to use.

I don't think JVM is what turns people off. It's a different paradigm. Every FP language is basically a niche these days even though you can hear great things about most of them(Elixir? Elm? Clojure? F#?). It's just that FP is not popular/common enough for these languages to be popularized like some other OO languages.

Elixir seems to be pretty popular here on HN these days.

HN is not a good representation of the programming world at all.

It does tell you what legacy code bases you'll be maintaining in ten years though ;)

JVM and .NET are the top runtimes with best in game GC implementatios, JIT compilers, JIT code cache, and monitoring tools for production code.

In fact plenty of them, given that there are multiple implementation to choose from.

Meanwhile other languages keep playing catchup and having to rewrite extensions in C.

Your comment prompted me to google for those tools once more. One that I did not know about before is Eclipse Memory Analyzer. The screenshots[1] look promising, especially "Path to GC Roots". I didn't know that was possible. Is there something comparable for .NET?

[1]: <https://www.eclipse.org/mat/about/screenshots.php>

EDIT: A bit more googling and I found <https://memprofiler.com/> for .NET which seems to have a similar feature, called "Instance Graph".

Eclipse Memory Analyzer is quite good, but something like Java Flight Recorder is much more capable.

On the .NET side of the fence, you can have a look into this nice article although a bit old,

https://mattwarren.org/2018/08/21/Monitoring-and-Observabili...

and "ETW - Monitor Anything, Anytime, Anywhere"

https://www.youtube.com/watch?v=ZNdpLM4uIpw

The runtimes themselves may be great, but the tooling is bloated and uncomfortable.

Every time I use Clojure, I am reminded how much I hate using Java. The error messages alone are enough to turn me away. So is having to set up a whole Leiningen project just to get started.

A Clojure without Java would be very attractive to me.

There is nothing else that gets close to the world promised to us by Xerox PARC.

Don't blame Java for the issues that are Clojure's fault.

The only Lisps that can match such tooling are Allegro and LispWorks.

Well, I owned a Xerox Lisp Machine from 1982 to about 1987. True, a great programming environment, but the situation is so much better today. For example, I own a LispWorks Professional license, and the support and quality of the product is fantastic. My friends at Franz have similar quality products like Allegro and AllegroGraph. Even Clojure+Cider or Haskell+Intero or Haskell+VSCode (easiest to set up) is arguably better than dealing with lack of deployment options for Lisp Machines.

Yeah, let me take the opporunity to thank you for the books.

you are welcome!

I usually use Cider + Emacs for Clojure. Cider let’s you interactively check values and makes error messages more understandable, at least to me.

I think that many Clojure programmers skip the JVM and use ClojureScript with node. Personally, given my history with Java I find that Lisp + JVM ecosystem is why I use Clojure sometimes instead of Common Lisp.

For writing simple scripts and stuff I like to use babashka[1], which is a simple clojure interpreter that's compile to a binary, so there's no JVM or leiningen to worry about. Of course, it's slower than the JVM hosted clojure once the JVM is started, so it's basically best for simple tasks.

[1] https://babashka.org/

Scala can be enjoyable but can be a major pain as well. Look no further than the de-facto standard build tool (sbt).

as both a Scala and Clojure polyglot I would pick Clojure over Scala every single time, the Clojure REPL development style alone puts Scala behind.

Scala and SBT is a nightmare, I don't want to touch it ever again.

With Clojure you are done before Intellij has even rebuilt your indexes /s.

The JVM is best in class, and has great ecosystem (with some noteable omissions).

Scala is a different beast: modern Java negates the need for a lot of it, and the community tolerance and support for bigots and abusers justifiably distances many.

The JVM is a blessing and a curse. I believe it was a very good decision and that Clojure wouldn't have become as useful or popular as it is without it, because it provided immediate and quick access to a huge ecosystem, allowing it to be productive and useful right away. But its also hindering further adoption and may be part of what caused a bit of a decline in interest, which for an already niche language, doesn't help. Many people are turned off the JVM.

I personally don't mind it and I love Clojure, but even I have been wondering whether I should port some services to something else because I've had to use larger cloud instances for them simply due to memory requirements... Maybe I can run them on node with Clojurescript instead, I'll have to investigate that, but I think I'll lose out on a ton of libraries that I use that rely on the JVM. Hmm.

According to LibHunt's popularity index, it's the 28th most popular language https://www.libhunt.com/index#clojure (ahead of Elixir that is 40th).

It is less than 50th position on Tiobe's index https://www.tiobe.com/tiobe-index/ (which is a bit more reputable than LibHunt's)

Yeah but does any programmer actually believe these indices? I have yet to see one with a prelude where they defined "popular" in a way that would make anyone with a passing knowledge of stats happy.

Reply on news.ycombinator.com