> JIT warmup is real. The first call to any method pays the compilation cost. In a database engine, the first transaction after startup shouldn’t be 100x slower than the steady state.

Correct me if I'm wrong but isn't it what aot was supposed to solve?

▲ nycdotnet an hour ago | parent | next [-]

In the section “Hardware-accelerated WAL checksums” he explains how the JIT compiles away the hardware support stuff depending on the exact capabilities of the system its on. With AOT you don’t get this - it’s way more coarse like x64 vs ARM

▲ landl0rd 2 hours ago | parent | prev | next [-]

AOT is a little fussy in real-world usage particularly for things like reflection. You can probably force it to work but it may make your code much uglier.

Span<T> is more important for performance TBH JIT warmup isn't a huge issue for a long-running process

▲ CharlieDigital 2 hours ago | parent | next [-]

    > ...but it may make your code much uglier

Flip side is that if you use more source generation, it may end up making the code more terse/"prettier" where it matters and avoid the reflection hit.

AI agents seem fairly good at generating source generators so there doesn't seem to be a reason to not use them.

▲ orphea an hour ago | parent | prev | next [-]

What's fussy about AOT and reflection?

	▲	pjc50 28 minutes ago \| parent [-]
		Only a subset of reflection is actually AoT safe, and you can run into issues like "the method you wanted to call wasn't statically referenced anywhere, so there is no compiled implementation of it".

▲ sebazzz 2 hours ago | parent | prev [-]

With UnsafeAccessor you can often avoid reflection.

▲ pjc50 22 minutes ago | parent | prev [-]

Eh, I don't see that as a huge deal because the first thing the DB has to do is warm up the disk cache, at least for the indexes. Of course the first call is slow.