[kbd]

> I guess I might ask what this stance is founded on?

Kotlin has Kotlin/Native, so I was hoping there might be a similar initiative for Clojure. But, a few reasons:

* Startup time

* Ability to deploy/share a binary

* The JVM just seems so "heavy" to me. It's certainly the only language runtime I know of that runs a persistent helper app, or asks to install an Ask toolbar upon installation.

* Bias against Oracle and Java

> Also I think recent Java releases have gotten into making self contained binaries

TIL, thanks.

Edit: edited.

[lenkite]

You can use Graal native image to compile Clojure apps to single binaries. https://www.astrecipes.net/blog/2018/07/20/cmd-line-apps-wit...

There is also a lein (clojure build tool) plugin for this at https://github.com/taylorwood/lein-native-image

[zmmmmm]

> * Bias against Oracle and Java

It's always fascinating when I encounter people with opposite biases to my own. While I'm no fan of Oracle, I seek out technologies that are based on the JVM and try to avoid things based on many other technologies because I intrinsically trust certain behaviors and features of the JVM that other ecosystems lack.

[kbd]

After suffering through Java early in my career I've completely avoided it since then. What parts of Java/JVM do you find indispensable vs the rest of tech?

[zmmmmm]

Definitely more the language ecosystem than Java itself - coding in Java itself is painful to me as well. I actually write most of my code in Groovy, some in Kotlin and Scala. But these things keep me liking the JVM -

- maturity of the infrastructure (monitoring, debugging, IDEs, build tooling). I love that I can fire up my debugger and remote attach to a process running on some other host and set a breakpoint for a specific condition to catch a bug. Or that I can do the same to profile memory etc., all with very mature tools.

- very good performance - smack bang inbetween C/C++ and higher level languages (acknowledging that startup time is a big hole in that - but not an important one for me)

- truly cross platform - none of this python style, cross platform except half your packages are really written in C and won't compile unless an entire ecosystem of dependencies is there to support them, and even then some of the flat out don't work on some platforms. This extends deeper than most other languages ie: you can get closer to low level OS features while maintaining 100% cross platform capability.

- strong / static typing under the hood which you can access optionally (eg: languages like Groovy / Kotlin let you write high level code without being burdened too much by the overhead of static typing), but all the Java APIs, ecosystem of libraries are all statically typed so you have good guarantees and excellent documentation.

- deployment behavior - I can run the JVM, give it specified memory footprint and know it's going to stay within that

[lsh]

> Startup time

Java is not as bad as you think. Clojure does takes a little longer though

> Ability to deploy/share a binary

there are jar files, but I know what you mean.

Interesting work happening in GraalVM land: https://www.innoq.com/en/blog/native-clojure-and-graalvm/

> Bias against Oracle and Java

yeah, well ... we're all biased. It helps us make decisions quickly ;)

[kbd]

> Java is not as bad as you think. Clojure does takes a little longer though

For example, I have a Python script[1] that runs on each command prompt to print status about my current git repository. Just timed it, it runs in .08-.12 seconds within a repo and about .02s outside of a repo. I still want to rewrite it in C using libgit2 someday, but something like that would be unusable if it was written in Clojure.

[1] https://github.com/kbd/setup/blob/master/HOME/bin/repo.py

[ghufran_syed]

Yeah, for scripting you should use something like Planck: it uses clojurescript which is virtually the same language as clojure, but starts up super fast so is great for scripts: https://github.com/planck-repl/planck

[lsh]

absolutely, Clojure is not a scripting language and Planck is amazing.

There are issues with a Graal-compiled Clojure repl due to reflection (apparently), but I think it's only a matter of time before those geniuses come up with something.

[aidenn0]

And python tends to have fairly high startup time (compared to compiled languages) for any non-trivial script.

[ken]

> The JVM just seems so "heavy" to me.

Wouldn't any replacement need just as much "weight"? The GraalVM example (linked elsewhere) turns a 300KB Java program into a 25MB standalone binary. The JVM provides a lot of features, and they don't come free. That's why he chose it.