Evan Ovadia

New article! verdagon.dev/blog/impossibl… "The Impossible Optimization, and the Metaprogramming To Achieve It" TL;DR: If you warp your mind a bit, you can apply metaprogramming to speed up your code by about ~10x. Enjoy!

Just posted a new article! verdagon.dev/blog/group-bor… "Group Borrowing: Zero-Cost Memory Safety with Fewer Restrictions" TL;DR: Nick Smith's epic approach to better borrow checking. Take a look!

I *really* went off the deep end on this one. But it works, and in theory we can now build on top Rust's ecosystem! verdagon.dev/blog/exploring… "Crossing the Impossible FFI Boundary, and My Gradual Descent Into Madness"

@vale_pl This was *really* hard to get working, but worth it! I just called into a Rust crate directly from C without writing any glue code, quite a magical moment. The hardest part was navigating Rust's AST to resolve imports and aliases, to invoke the correct function. But it worked!

If we're right, then this could pave the way towards newer languages calling into and building upon Rust, in the same way C++ built upon C! verdagon.dev/blog/exploring… The most surprising part is that we're sending non-#[repr(C)]'d types into C. Heresy, but effective!

@Joebobo2000 @vale_pl Good ideas! And, nicely done =) verdagon.dev/blog/easter-eg…

Behold! Higher RAII, and the Seven Arcane Uses of Linear Types: verdagon.dev/blog/higher-ra… It turns out, you unlock pretty sorcerous powers when you make it so only specific functions can destroy a certain type. Also, it's very weird that a language could help with caching.

@vale_pl Pretty excited about this one. I've been exploring linear types and higher RAII for *years*, looking for use cases, especially on HN and in the Vale and Austral discords. (@zetalyrae's probably real tired of me bringing it up all the time in there!)

Pretty proud of this technique! (though I'm not the first to find it) verdagon.dev/blog/llm-throu… Basically, batching + layer-wise inferencing from disk, which means we can run large LLMs on tiny devices without losing throughput.

New article! "Borrow checking, RC, GC, and the Eleven (!) Other Memory Safety Approaches" verdagon.dev/grimoire/grimo… I'm starting to sense a theme in my articles: a lot of archaeology metaphors. Hopefully nobody notices!

Had a ton of fun talking linear types, regions, and Vale with @krisajenkins (of Developer Voices), always enjoy geeking out with fellow programmers about the weird directions programming can go! youtube.com/watch?v=UavYVf…

@daniel_thilo @vale_pl Thank you!

@vale_pl @verdagon Impressive!

At long last, the first prototype of immutable region borrowing in Vale! verdagon.dev/blog/first-reg… This technique removes Vale's memory safety overhead by making borrowing and shared mutability work well together.

@muktabh @vale_pl Thanks =)

Welldone @vale_pl !

@vale_pl Regions are also a way to make colorless fearless structured concurrency (a mouthful I know), without going all in on a Rust-like borrow checker. verdagon.dev/blog/seamless-… Now that we have a working regions prototype, I can finally start working on concurrency!

@vale_pl This has been a long time coming! Regions are Vale's "killer feature", they let us write in a normal unrestricted way then incrementally optimize. This lets the user choose whether they their is flexible like Java, fast like Rust, or any point in between.

Blend #4, though I'm a tad unsure on this one. Something along the lines of the "MMM++" in verdagon.dev/blog/when-to-u… with pieces from the theoretical Arrrlang, at verdagon.dev/blog/myth-zero…. Basically, allocating from static type-specific arrays, like embedded code often does.

Blend #3: Blending arenas (Zig, Odin) with region borrowing (Vale) [1] and Pony's iso [2]. Similar in spirit to Verona [3], without GC. We alluded to it at Handmade, handmade.network/podcast/ep/afc…. [1] verdagon.dev/blog/zero-cost… [2] tutorial.ponylang.io/generics/gener… [3] github.com/microsoft/vero…

It turns out, there's a few ways we can make C++ memory-safe, if we blend some obscure techniques. Blend #1: Vale's gen refs / constraint refs plus Val-style borrowing. I go into it in verdagon.dev/blog/vale-memo…. (If only we had something from Vala too, we'd have the whole set!)

@vale_pl Linear types (and the higher RAII they enable) are pretty huge. Any time you say "Ah, I forgot to do X", that's a bug linear types help prevent. I wrote about this in verdagon.dev/blog/higher-ra… and have been discovering more and more uses for them ever since!

It turns out, one doesn't need borrow checking, RC, or GC to get memory safe single ownership! And with a little twist, we can enable compile-time guarantees that no mainstream language has been able to achieve. verdagon.dev/blog/single-ow… Enjoy!