My understanding is that Jank is built to provide tight integration with C++, and does not aim to be a drop in replacement for Clojure. Jolt provides FFI for native ecosystem access, and aims to be a superset of JVM Clojure leveraging platform specific features like TCO and providing fibers built on top of continuations. It currently runs many existing Clojure libraries out of the box.
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.
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.
> 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.
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.
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.
Was initially interested (I like languages that binds easily to C because of the nice libraries there, and I'm a fan of LISP), but the README is LLM-generated and the Makefile is unreadable. The there's this part in the AI policy
It is simply not feasible for humans to keep the entirety of large projects in their heads all at once. When working on a project, one is constantly forgetting and relearning code along the way. The situation is even worse for projects where multiple people work together and no one knows what everyone else was thinking. We look at the code and try to build up sufficient context in our heads to make the necessary changes. When we misjudge that context or misunderstand existing code, we end up making mistakes.
It's a made up excuse because no one has ever tried doing that. Instead the core activity of software engineering (and engineering in general) is to break down things into modular components, ensure that they work well, produce specs, then assemble the result. Which is why no one read the source code for open(2) system call before using it. Instead they read the manpage and only when there's an issue there's a need to compare the specs with the implementation.
So it's a matter of communication between humans. If person A is responsible for module 1 and person B's module 2 depends on the former. It's up to A to provide a proper spec to B. It's not up to B to learn everything about module 1's implementation and doing so is kinda foolish.
So something like
Any new code that is added is therefore always done with limited understanding.
Is a red flag. The codebase and workflow should be that new additions should deal with a limited context (as in one PR shouldn't touch unrelated things) at at time and the contributors should be able to come with a full understanding of what they are doing. If they cannot, it's either a failure of the codebase, the docs, the workflows, or the contributors.
I’m not even sure I agree it’s impossible for one person to understand a large codebase. It’ll depend on size of course but plenty of major pieces of software have been developed by a single person capable of understanding the whole codebase.
I've developed plenty of large software projects, and what happens in practice is that you build up the context for the part of the project you're working on when you make changes. If you could just hold the entirety of the project in your head we wouldn't need tools like debuggers or test harnesses at all. You'd just know that all the changes you made are correct. That's obviously not how things work in the real world.
Author here. Pointing out that we can't hold entire projects in our heads is not a made up excuse. And doing things like breaking things up into modular components that have specifications and tests is precisely how we combat cognitive complexity. That's exactly the approach I am taking with Jolt where there is a large specification and conformance harness used to ensure semantic correctness of the language. https://github.com/jolt-lang/jolt/tree/main/test/conformance
Meanwhile, anybody who's maintained a large scale software project knows that even with the best practices, problems can still be introduced into the codebase. Nobody is arguing against limiting context or doing as much as possible to ensure the contribution is doing the right thing. Yet, the idea that you can have full understanding of how the feature will interact with every edge case is frankly laughable.
The notion that you can architect a perfect codebase where context and scope of the effect of any change is always completely clear is idealistic in the extreme. Of course, we should strive to keep the code quality as high as possible, nobody is arguing against that. The reality is that large projects are complex, and nobody has come up with a way to write code in the way where it's possible to perfectly control the scope of the effects of any one change. Every single large scale project out there has bugs, and regressions no matter how much the authors strive to make it perfect.
> Yet, the idea that you can have full understanding of how the feature will interact with every edge case is frankly laughable.
That's not what I'm saying. What I'm saying is that the contributor should make a reasonable attempt at producing a bug free patch. And it's up to the project's leaders to make it easy to do so. And one of the easiest way for the latter to do so is producing design docs and isolating modules as much as possible so that it's efficient to get the needed understanding.
So both parties each have its own responsibilities into making quality contributions happen. I'm not against LLM usage. What I'm against is making the project difficult for human understanding because human understanding is limited or whatever. That's why I point out the README and the Makefile.
> I get the impression that you must be new in your programming career, and hold idealistic views of the reality of what maintaining large projects looks like in practice.
Personal attacks for someone pointing out some issues with the LLM apologetics. Nice.
disclaimer: 27 year professional in this field and I mostly agree with OP.
Anyone who's seen the author communicate here and on Lobsters will know that this particular critique irks them and they tend to react exactly like this when it comes up. It's a sore spot, and one the author should probably try to work through on their own since they seem to spend a lot of time vibecoding things.
If you have 27 years of professional experience in this field and still think that you can have total knowledge of how a piece of functionality interacts with the overall codebase in a large software project, then I really don't know what to tell you. If that was the case we'd be writing perfect software that never has bugs.
Also, I have no idea what any of this has to do with LLMs. Nothing discussed here was LLM related in any way. Nor am I doing any apologetics for anything here. I'm stating basic facts that anybody with even a modicum of intellectual integrity would acknowledge.
But if you have any actual counterpoints to what I said then feel free to share them.
Don't let the anti-AI people bug you. They seem to pounce on every thread and complain about LLM usage to the point where it drowns out any legitimate discussion.
I'm a heavy LLM user myself and it's reinvigorated my passion for coding again. I'm making things I never would have otherwise made. I probably wouldn't even be writing code anymore. I've worked on large codebases in my career and I felt like I understood them well. Still, it was so time consuming to get to that point in the first place and I would still have to familiarize myself all over again when working on components that didn't get touched often. An LLM makes it so much easier.
Ultimately, the developer has to own the code and be accountable for it. As long as that's true, I don't see what difference it makes what tools the developer uses. It's true that you can shoot yourself in the foot with an LLM, but you're probably going to shoot yourself in the foot without one too.
Curious how it compares to Jank which is also Clojure but for C++.
https://news.ycombinator.com/item?id=50202762
https://jank-lang.org/
My understanding is that Jank is built to provide tight integration with C++, and does not aim to be a drop in replacement for Clojure. Jolt provides FFI for native ecosystem access, and aims to be a superset of JVM Clojure leveraging platform specific features like TCO and providing fibers built on top of continuations. It currently runs many existing Clojure libraries out of the box.
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.
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.
> 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.
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!
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.
> 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.
Was initially interested (I like languages that binds easily to C because of the nice libraries there, and I'm a fan of LISP), but the README is LLM-generated and the Makefile is unreadable. The there's this part in the AI policy
It's a made up excuse because no one has ever tried doing that. Instead the core activity of software engineering (and engineering in general) is to break down things into modular components, ensure that they work well, produce specs, then assemble the result. Which is why no one read the source code for open(2) system call before using it. Instead they read the manpage and only when there's an issue there's a need to compare the specs with the implementation.So it's a matter of communication between humans. If person A is responsible for module 1 and person B's module 2 depends on the former. It's up to A to provide a proper spec to B. It's not up to B to learn everything about module 1's implementation and doing so is kinda foolish.
So something like
Is a red flag. The codebase and workflow should be that new additions should deal with a limited context (as in one PR shouldn't touch unrelated things) at at time and the contributors should be able to come with a full understanding of what they are doing. If they cannot, it's either a failure of the codebase, the docs, the workflows, or the contributors.I’m not even sure I agree it’s impossible for one person to understand a large codebase. It’ll depend on size of course but plenty of major pieces of software have been developed by a single person capable of understanding the whole codebase.
I've developed plenty of large software projects, and what happens in practice is that you build up the context for the part of the project you're working on when you make changes. If you could just hold the entirety of the project in your head we wouldn't need tools like debuggers or test harnesses at all. You'd just know that all the changes you made are correct. That's obviously not how things work in the real world.
Author here. Pointing out that we can't hold entire projects in our heads is not a made up excuse. And doing things like breaking things up into modular components that have specifications and tests is precisely how we combat cognitive complexity. That's exactly the approach I am taking with Jolt where there is a large specification and conformance harness used to ensure semantic correctness of the language. https://github.com/jolt-lang/jolt/tree/main/test/conformance
Meanwhile, anybody who's maintained a large scale software project knows that even with the best practices, problems can still be introduced into the codebase. Nobody is arguing against limiting context or doing as much as possible to ensure the contribution is doing the right thing. Yet, the idea that you can have full understanding of how the feature will interact with every edge case is frankly laughable.
The notion that you can architect a perfect codebase where context and scope of the effect of any change is always completely clear is idealistic in the extreme. Of course, we should strive to keep the code quality as high as possible, nobody is arguing against that. The reality is that large projects are complex, and nobody has come up with a way to write code in the way where it's possible to perfectly control the scope of the effects of any one change. Every single large scale project out there has bugs, and regressions no matter how much the authors strive to make it perfect.
> Yet, the idea that you can have full understanding of how the feature will interact with every edge case is frankly laughable.
That's not what I'm saying. What I'm saying is that the contributor should make a reasonable attempt at producing a bug free patch. And it's up to the project's leaders to make it easy to do so. And one of the easiest way for the latter to do so is producing design docs and isolating modules as much as possible so that it's efficient to get the needed understanding.
So both parties each have its own responsibilities into making quality contributions happen. I'm not against LLM usage. What I'm against is making the project difficult for human understanding because human understanding is limited or whatever. That's why I point out the README and the Makefile.
> I get the impression that you must be new in your programming career, and hold idealistic views of the reality of what maintaining large projects looks like in practice.
Personal attacks for someone pointing out some issues with the LLM apologetics. Nice.
disclaimer: 27 year professional in this field and I mostly agree with OP.
Anyone who's seen the author communicate here and on Lobsters will know that this particular critique irks them and they tend to react exactly like this when it comes up. It's a sore spot, and one the author should probably try to work through on their own since they seem to spend a lot of time vibecoding things.
If you have 27 years of professional experience in this field and still think that you can have total knowledge of how a piece of functionality interacts with the overall codebase in a large software project, then I really don't know what to tell you. If that was the case we'd be writing perfect software that never has bugs.
Also, I have no idea what any of this has to do with LLMs. Nothing discussed here was LLM related in any way. Nor am I doing any apologetics for anything here. I'm stating basic facts that anybody with even a modicum of intellectual integrity would acknowledge.
But if you have any actual counterpoints to what I said then feel free to share them.
Don't let the anti-AI people bug you. They seem to pounce on every thread and complain about LLM usage to the point where it drowns out any legitimate discussion.
I'm a heavy LLM user myself and it's reinvigorated my passion for coding again. I'm making things I never would have otherwise made. I probably wouldn't even be writing code anymore. I've worked on large codebases in my career and I felt like I understood them well. Still, it was so time consuming to get to that point in the first place and I would still have to familiarize myself all over again when working on components that didn't get touched often. An LLM makes it so much easier.
Ultimately, the developer has to own the code and be accountable for it. As long as that's true, I don't see what difference it makes what tools the developer uses. It's true that you can shoot yourself in the foot with an LLM, but you're probably going to shoot yourself in the foot without one too.
Anyway, cool project. Thanks for sharing it.
Yet another project named Jolt?
https://github.com/jrouwe/joltphysics
https://github.com/bazaarvoice/jolt
https://github.com/a16z/jolt
https://github.com/jordond/jolt