Welcome! I'm Evan Ovadia, a software architect, hobbyist game developer, and lead for the Vale Programming Language.
I use this site to blog about my endeavors. Enjoy!
Recent posts:
- Crossing the Impossible FFI Boundary, and My Gradual Descent Into Madness
- Exploring Seamless Rust Interop for Newer Languages, Part 1
- Higher RAII, and the Seven Arcane Uses of Linear Types
- Layer-wise inferencing + batching: Small VRAM doesn't limit LLM throughput anymore
- Borrow checking, RC, GC, and the Eleven (!) Other Memory Safety Approaches
- Vale's First Prototype for Immutable Region Borrowing
- Generational References (Updated)
- Making C++ Memory-Safe Without Borrow Checking, RC, or Tracing GC
- Chasing the Myth of Zero-Overhead Memory Safety
- Single Ownership and Memory Safety without Borrow Checking, RC, or GC
- The Link Between Generics, Compile Times, Type-Erasure, Cloud Building, and Hot-Code Reloading
- What Vale Taught Me About Linear Types, Borrowing, and Memory Safety
- Implementing Vale's Region Borrowing, and its Unexpected Quest
- How To Survive Your Project's First 100,000 Lines
- Memory Safety Approaches and Development Velocity
- Implementing a New Memory Safety Approach, Part 1
- Zero-Cost Borrowing with Vale Regions (Preview)
- Hash Codes, Non-Determinism, and Other Eldritch Horrors
- Safety in Non-Memory-Safe Languages
- Perfect Replayability
- Vale's Fearless FFI, for Safer Dependencies and Supply-Chain Attack Mitigation
- Vale 0.2 Released
- Added to Vale 0.2 Beta: Concept Functions
- Const Generics and the Compile Time Spread Operator
- On Removing Let and Let Mut
- A Tale of Yak Shaving: Accidentally Making a Language, for an Engine, for a Game
- Surprising Weak-Ref Implementations: Swift, Obj-C, C++, Rust, and Vale
- Vale's Higher RAII, the pattern that saved me a vital 5 hours in the 7DRL Challenge
- Seamless, Fearless, Structured Concurrency
- Generational References
- Hybrid-Generational Memory
- Zero Cost References with Regions
- Next Steps for Single Ownership and RAII
- Announcing Vale!
Game Dev
I also do game development on the side, primarily for the 7DRL challenges!
Shattered Forest (2021)
Shattered Forest was a grand experiment in how insane we could make terrain. Its levels had paths that criss-crossed over each other, as the player could hop a few tiles away, as long as the source and destination had the same elevation.
Ember Deep (2020)
Ember Deep was the first game to use Geomancer, the pentagonal tiling editor.
It also improved a lot on Incendian Falls' time-traveling mechanic.
Incendian Falls (2019)
Incendian Falls was the first prototype of the Chronobase time-travel system. It used a DSL to define an entire database and API that allows reverting to arbitrary revisions, with built-in pauseless compaction.
I gave a talk at the 2019 Roguelike Celebration conference about Domino, the unique art style.
It was also the first game to ever use pentagonal tiling. Pretty trippy, right?
Vale
My biggest endeavor is Vale, a statically-typed ahead-of-time-compiled language that aims to be fast, safe, and flexible.
I'm combining the best parts of C++, Rust, and Scala (and even a tiny bit of Javascript!) with some novel innovations:
- Generational Memory, an alternative to RC, GC, or borrow checking.
- HGM, speeding up Generational Memory with "LifeCell"s.
- Region Borrow Checking, which allows us to temporarily treat all pre-existing memory as immutable, enabling optimizations and seamless structured concurrency.
Check it out at https://vale.dev/!
exported func main() {
planets = [#]("Venus", "Earth", "Mars");
foreach planet in planets {
println("Hello " + planet + "!");
}
}Hello Venus!
Hello Earth!
Hello Mars!Software Engineering
I've worked on Google Earth, Google Chat, and Google MyMaps.
Google Earth
I worked on Earth from 2016 to 2019. I was all up and down the stack, but spent most of my time in the C++ core, making the program correctly handle state transitions and synchronizing state with the server.
Earth was a fascinating program. It had so many moving parts with asynchronous operations, and we had to bring all of our architectural jujitsu to keep it all stable. I'm particularly proud of the unidirectional data-flow, built-in self-testing, and state management systems.
Google Chat
From 2019 to 2021, I was on the Google Chat team, diving deep into their server and client-side codebases to diagnose architectural problems and identify the sources of common bugs, and redesigning their core Message object to be more reliable in the face of a rapidly evolving feature set.
Chat was one helluva challenge. My favorite memory was when the director told me "We have a lot of problems with our message object. I need you to figure out what's causing them and fix them," which led to a months-long odyssey of archaeology and traveling to distant locales to talk to mystics present and past to figure out what the heck caused the codebase to get in its current state. That quest spawned 5 massive re-architecting projects.
Google MyMaps
I was on the MyMaps team from 2014 to 2016, on the web client team, mostly revamping the site to use Material design. Along the way, I redesigned their panel state system, which would later inform the designs for Earth's state system.
Make maps!