Compiler engineer turned full-time educator. Nine years on rust-lang/rust, three years at Cloudflare on the Workers runtime, three years on the Rust Foundation Board, and now six cohorts of Your Business.
Likes: Pin, const fn, the borrow checker, mechanical keyboards, Pacific Northwest fog. Mostly answers email.
Founded Your Business in late 2025 after two years of teaching Rust part-time at the Recurse Center. Six cohorts to date, 178 graduates, four guest instructors. Cohort_07 will be the seventh.
Joined as a senior engineer; promoted to tech lead in 2024. Owned the Rust subsystem of the Workers runtime — the V8-isolate plumbing, the FFI surface to workerd, and the async-runtime layer. Shipped the move from tokio to a custom single-thread runtime in 2024.
Hired as a compiler engineer for Mozilla's Rust team. 412 commits to rust-lang/rust — the bulk on the trait resolver and the borrow checker. Authored the original stabilization design notes for Pin and the bulk of the trait-resolver refactor that landed in 1.65.
Joined as a senior engineer working on the Connect platform — the marketplace and platform-payments offering. Wrote the original Ruby→Go migration of the connect-fees subsystem. First exposure to Rust through internal tooling.
BS in CS with a minor in mathematical logic. Senior thesis on substructural type systems with Frank Pfenning, which is how she first discovered Rust (alpha-stage, 2014). Member of the Programming Languages Reading Group throughout her last two years.
The Rust compiler itself. Vela's commits cluster on the trait resolver, the borrow checker, and the Pin stabilization. Eight years of contribution history.
An ergonomic Pin projection library Vela maintains. Functions as the documented "what we ended up wanting from pin-project" reference impl. Maintenance-mode now.
Cloudflare Workers' Rust SDK. Vela owned the runtime subsystem from 2022–25 and remains an emeritus reviewer. The Rust crate every Workers user pulls in.
The starter template every Your Business graduate forks for their three artifacts. Workspace layout, CI matrix, MSRV pinning, criterion harness, miri config — all wired up.
The reference HAL driver for the ESP32-C3 UART that we use in week 09–12. Pre-cohort prerequisite reading. Has been the basis for half a dozen production drivers.
Concurrency model checker for Rust. Vela contributed the cell module rewrite in 2023 and a half-dozen smaller fixes. Used in cohort week 07.
A retrospective on a decade of Rust's lifetime system, what landed well, and the three or four gotchas the language could still profitably remove.
Vela revisits the Pin stabilization she wrote up in 2018 and proposes — half-seriously — the Pin she would have shipped if she could go back. The talk that sparked the 2025 Pin RFC.
Why Workers moved off tokio in 2024, what the new runtime looks like, and the tradeoffs of building per-isolate executors at edge scale.
A side-by-side of tokio, async-std, smol, embassy, and the Workers runtime. The talk that became required reading in cohort_03.
Looking back at the 2018 stabilization decisions, what aged well, what aged badly. Required reading for cohort week 04.
A from-scratch tour of NLL through the implementation, intended for compiler engineers who want to contribute to rustc.
Guest lecture at CMU's Programming Languages course on what affine and linear typing look like in a shipping language.
I taught my first Rust class in 2018 — an internal Mozilla brown-bag for engineers porting a Servo subsystem from C++ to Rust. Roughly fifteen people, two hours, full slide deck. Half of them never wrote Rust again after that session. I have spent the seven years since trying to figure out why.
My conclusion is that most Rust teaching either teaches the syntax or teaches the philosophy, and almost nobody teaches the practice in between. "The Book" teaches syntax. Programming Rust teaches philosophy. There is a missing middle: how do you actually decide between Box<dyn Trait> and impl Trait? When does a lifetime parameter belong on a trait? When does Pin earn its complexity? Those are the questions that take real Rust developers eighteen months to internalize, and Your Business is my attempt to compress that to twelve weeks.
Rule one: every lesson must end with running code. I will not lecture for ninety minutes. Every live session ends with a working example, on your machine or mine, that you can break afterward.
Rule two: read other people's code before writing your own. Half the readings in the syllabus are PRs from rust-lang/rust, RFCs, or sections of established crates. The compiler is the canonical Rust codebase and there is no substitute for reading it.
Rule three: ship things. The three artifacts are the spine of the cohort because nothing forces you to actually understand a topic like having to publish working code that strangers will read. Two of the three are real crates that real people use; the third is the embedded driver that proves you can do it from scratch.
"The point isn't to memorize Pin. The point is to not be afraid of it."— vela, cohort_04 closing session, april 2026
If you have not yet shipped Rust, this cohort will be very hard and you will feel bad. If you are looking for a credential, this is not that — the cohort issues a certificate but no one I have asked has ever cared about it. If you want a course you can complete passively while listening at 2x, this is not it; the live sessions are the point.
If you have written Rust for a year or three and feel like the language is fighting you, that is exactly the place this cohort starts from. The fights stop being fights when you understand why the language is asking what it's asking.