Hacker News

> resulting VM outperforms both my previous Rust implementation and my hand-coded ARM64 assembly

it's always surprising for me how absurdly efficient "highly specialized VM/instruction interpreters" are

like e.g. two independent research projects into how to have better (fast, more compact) serialization in rust ended up with something like a VM/interpreter for serialization instructions leading to both higher performance and more compact code size while still being cable of supporting similar feature sets as serde(1)

(in general monomorphisation and double dispatch (e.g. serde) can bring you very far, but the best approach is like always not the extrem. Neither allays monomorphisation nor dynamic dispatch but a balance between taking advantage of the strength of both. And specialized mini VMs are in a certain way an extra flexible form of dynamic dispatch.)

---

(1): More compact code size on normal to large project, not necessary on micro projects as the "fixed overhead" is often slightly larger while the per serialization type/protocol overhead can be smaller.

(1b): They have been experimental research project, not sure if any of them got published to GitHub, non are suited for usage in production or similar.

Finally! Tail calls! I had to write rust some years ago, and the ocaml person in me itched to get to write tail recursion.

Tail recursion opens up for people to write really really neat looping facilities using macros.

More accurate title would be to say it is a tail call optimized interpreter. Tail calls alone aren't special b/c what matters is that the compiler or runtime properly reuses caller's frame instead of pushing another call frame & growing the stack.

i like it because it’s in rust