erichocean

Bizarre, it has a nearly identical improvement as the flash model.

It took 90 days earlier this year for our venture-backed business to get approved by Apple merely for a corporate developer account, with all documentation available at the beginning of the process.

They are insanely, glacially slow.

> I've been able to formally verify that the Rust behavior is identical to the Postgres C behavior for over 1000 of them.

Since both Rust and C have LLVM IR intermediates, you could use KLEE[0] for this.

[0] https://klee-se.org/

That's because it has the best compaction of anyone, and it's not even close.

Claude might as well not even do it in my experience.

The article did nothing of the sort: https://x.com/dhh/status/2081435971678261344

However, even if it did, it is absurd for an AI to decide what it will and won't translate.

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>")

=> actual, compiled Clojure function built up by `foo` parsing the string, producing a Clojure list, and calling `(eval the-list)` and returning it.

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.