erichocean

I mean if you're going to be that pedantic, then Clojure is "native" since all Clojure functions "compile to machine code" via the JVM's JIT.

https://github.com/cmuparlay/psac is extremely fast, I use it to recompute sculpting topology updates (think: Zbrush DynaMesh) at 60 fps.

Parallel Self-Adjusting Computation[0] is a fun entry in this genre.

[0] https://github.com/cmuparlay/psac

You can directly call C++ as C++, not via a C ABI.

Since Java 25/Project Panama, I have that kind of relationship with C from Clojure as well.

Codex can one shot the bindings flawlessly, and the interface is significantly faster for downcalls vs. JNI.

Whatever the group owner picks, same as it's always been.

No one cares about the actual choice, only that it is made.

I'm eagerly awaiting "AI 2100" from the same people.

Are there examples of where we have collective decided not to pursue knowledge? Successfully?

Studying human bio-diversity since WW2 is the most obvious example, though it hasn't been entirely successful.

Genomics is what finally broke the barrier, especially in the last decade or so.

reviewing the testing/fuzzing process

I've got insanely good at designing testing oracles over the last year for exactly this reason.

I've ported some extremely finicky software between languages that it would have been borderline abusive to have a human do.

Codex 5.3 and later for those interested.

I think the key is to get two LLMs looking at the same problem.

I use Codex because it's better at the kind of code I need written (math-heavy, 3D geometry code).

But if I was doing mainly UI code, I would do the opposite.

The arguments presented to a macro don't have to be valid code. Your "function evaluating functions" are all individually valid functions you've composed at runtime.

    (defmacro foo [code] ,,,)
    (foo "<some totally different language in a string>")

I passed a string to `foo` in the example, but it could actually be anything the Clojure reader can parse even if it is semantically invalid—arbitrary Clojure data.

Here you go: https://www.marktarver.com/bipolar.html

It's been discussed many times on HN.

this just isn't the kind of professionalism needed for a serious project

It hasn't stopped Rust's growth, so I doubt this is true.

Most people don't care about this kind of interpersonal drama unless it impacts the actual technology itself.

I use Claude for planning, writing CRs, and code review.

Codex writes all of the code, no exceptions.

Works great, especially when you ask Claude to break up large CRs into roughly 10 minutes of Codex work each.

That's the approach I've taken with a bunch of legacy OpenCL code I've mechnically translated to Metal, worked great.

TigerBeetle has you covered then.

Even at $165K, it's worth it to have a better base to build on top of—especially since it didn't take a year's worth of time for three programmers.

It took about two weeks for me to be able to read it.

Might as well have been Russian.

Now it's as natural as any other language.

It's 100% opt-in at the call site and doesn't affect existing code, so no?

Many people (including myself) already have checked key variants for maps; this mainly extends the syntax to destructuring too.

If you are skilled in the field already, yes.

Though it's not just "ask" in the one-shot prompt sense, but more in the "over the course of a few days" sense.

Another interesting LMDB fork: https://github.com/datalevin/dlmdb

My depraved mind wants to see Jank [0] running on Fil-C, using Fil-C's garbage collector.

[0] https://jank-lang.org/

If you like this kind of thing, Bifurcan [0] is a Java library with implementations of RBB-trees and related (fast) immutable data structures.

[0] https://github.com/lacuna/bifurcan

The only time I ever really found that GA was actually a benefit to me was performing rotations.

Maybe that's why I've found it so useful when doing rigging for animation—that's the entire job!

Personally, I've got a line of mileage out of using GA to express animation rigs.

I don't know about the rest of the article—I'm not a mathematician—but I certainly enjoying using GA a lot more compared to linear algebra, I find it way more intuitive and being able to visualize intermediate products on my rig is like a super power.

If it was that easy, I wouldn't have commented.

It's not, which is why it would be nice if they did the actual work (on your hardware).

I would 100% pay $16/hr to run a self-hosted instance, but I won't spend thousands of dollars to (maybe) get it working (my time + the hardware).

Half the code was written in a language you didn't understand. The other half was written using libraries you never heard of.

The author already describes himself as "not a rockstar developer", but if this is the definition of "rockstar" I need to recalibrate.

Being able to learn new languages and libraries, to me, is completely normal.

(Also: how funny is it to suggest rewriting code you self-admit you can't even read.)

I wish you guys could partner with Modular to get Mojo inference working on your hardware, e.g. https://www.modular.com/models/deepseek-v4-pro

There are deep reasons for the variations, especially around (reader) macros.

I suspect the author created his own IR after being offered that suggestion earlier, he's definitely aware it exists.