upvote
I am the author of jank. Saying that jank "does not aim to be a drop in replacement for Clojure" may send the message that jank is not a full Clojure dialect. This is unclear at best. jank is a native Clojure dialect with seamless C and C++ interop and a strong native ecosystem story, including native project and dependency management.

I believe what you're trying to say there, with "drop in replacement", is that jolt emulates common Java interop forms in Clojure JVM such that code written for Clojure JVM doesn't need to be ported to run on jolt. This a compelling feature which other dialects are tackling as well.

What I would mention as a key difference between jank and jolt, aside from the C++ story and native project management story, is that jolt is very much AI coded and jank is not. jolt doesn't disclose this on its website or Github readme, but it's something which clearly matters to a lot of people.

reply
I'm looking forward to trying out jank!
reply
Fwiw, I’d like to see both succeed, while taking very different approaches.

Jeaye, you’ve been doing amazing work on jank over the years, please keep going!

reply
It doesn't disclose but also doesn't hide it. Author obviously cares more about the product than about the ideology.
reply
It feels superficially similar to the recent vibe-clones of unreleased games, competing with the original for attention purely on time to market, or even blackmailing the dev, demanding ransom to not release it...

I've been occasionally checking up on jank for a few years now, and thanks for resisting the temptation to go slop and doing things the proper way.

reply
You are correct about being completely superficial in your 'analysis'. Jolt is not a clone of Jank in any way shape or form, it makes completely different design decisions, and it has different goals.

The language exists because I wanted to be able to use Clojure on a proper Lisp runtime, and to have access to the native ecosystem so that I could build native apps for my own use. Jank has never been a consideration for me here one way or the other.

I'd also point that I'm in no need of some additional clout having been publishing Clojure open source projects for over a decade now.

reply
> doing things the proper way

You mean the classic way. A lot of compiler development is happening now using AI in very mainstream projects like Ruby, to giant billion-dollar projects like Mojo, to brand new indie languages like Roc. It's not an improper way of working, just a new way.

reply
Correct me if I'm wrong, but I recall you mentioning that your stance is that there were no immediate plans to implement features such as protocols in Jank?

Jolt aims to faithfully implement the totality of features that current JVM Clojure implements along with shim for Java surface to facilitate existing code to run.

Meanwhile, I don't see the tooling used to develop the language as the key difference in the language itself. I understand this is important for some people, and that's fine. However, that has little to do with the language itself , its features, or its overall functionality. So, for me personally, that is not an interesting distinction. What matters to me is what I can use the language for, and what code it is able to run.

reply
> Correct me if I'm wrong, but was your stance that there were no immediate plans to implement features such as protocols in Jank?

Protocols, records, and Clojure structs will definitely be a part of jank. They have been lower priority than improving some of the more commonly used Clojure features, smoothing out the C++ interop edges, and providing excellent tooling. Still, I have been working toward supporting them already. jank will have them before its production release.

> Jolt aims to faithfully implement the totality of features that current JVM Clojure implements along with shim for Java surface to facilitate existing code to run.

Yes, this is a neat approach. Making dialects maximally portable across existing Clojure JVM code is compelling and I think jolt's momentum, due to your usage of AI, has allowed you to pioneer an approach here faster than other dialects have done. In the coming couple of years, I can see us arriving at a more wide-spread approach of registering these shims so that the large corpus of Clojure JVM code can be used in various dialects without requiring library authors to add reader conditionals everywhere.

However, "Clojure" these days doesn't only mean Clojure JVM. We don't yet have a specification for Clojure, but reasonably the intersection of Clojure JVM, ClojureScript, and ClojureCLR is the target compatibility point for most dialects. For example, ClojureScript doesn't have JVM interop, emulated or otherwise. But nobody would ever say that ClojureScript is not Clojure. I discussed this exact point in my Conj talk this year, since there seems to be some outdated reasoning that "Clojure" means Clojure JVM. It does not.

> Meanwhile, I don't see the tooling used to develop the language as the key difference in the language itself. I understand this is important for some people, and that's fine. However, that has little to do with the language itself , its features, or its overall functionality. So, for me personally, that is not an interesting distinction. What matters to me is what I can use the language for, and what code it is able to run.

Yep, I understand this philosophy. I can appreciate it. The reason why I bring up disclosure is because you and I both know that this is divisive. There are people who will see jolt as a front-runner, due to its AI usage, and there are people who would rather abstain or at least wait until the dust settles. Providing people the necessary information on the label so that they can make this decision themselves is the respectful, transparent thing to do. I need to do better here as well and I have already publicly stated I will update the jank repo and website with clear disclosures for how I have used AI, which is mainly for troubleshooting and bug fixes. This will be coming with the beta release.

reply
Having a portable Clojure API that's decoupled from the JVM would be ideal going forward. That would make life much simpler for both dialect and library maintainers.

In my opinion, the reader conditional approach simply doesn't scale because it puts the burden on the library author to maintain conditionals for each dialect and to understand how the dialects work internally. It's clearly a better approach to have a common API that libraries target, and then each dialect can implement in the way that makes sense for it.

I suspect we're still a little while away from that though, and in the meantime creating Java shims seems to be a reasonable approach to take in order to support existing code. That can also help inform what the Clojure centric API needs to cover which is an additional benefit of doing this work.

While I agree with you in a philosophical sense that Clojure as a language should not be viewed solely through the lens of its existing host platform, there is the practical aspect of being able to leverage the existing ecosystem from a particular dialect. I'm using Jolt for my own work and personal projects, so I want to be able to use mature libraries that I'm familiar with like Ring, Reitit, Malli, Selmer, and so on. These allow me to build real world projects without having to bootstrap the whole ecosystem from ground up.

And to the final point, I've always been up front about LLM usage in the project, and Jolt now has a clear AI policy in the repo as well that people can read: https://github.com/jolt-lang/jolt/blob/main/AI_POLICY.md

So, I would hope that nobody feels deceived in any way here.

reply