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.
skydhash 56 minutes ago [-]
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.
trescenzi 27 minutes ago [-]
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.
yogthos 23 minutes ago [-]
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.
yogthos 25 minutes ago [-]
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. 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.
https://news.ycombinator.com/item?id=50202762
https://jank-lang.org/
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.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. 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.
https://github.com/jrouwe/joltphysics
https://github.com/bazaarvoice/jolt
https://github.com/a16z/jolt
https://github.com/jordond/jolt