What I do for a living is best described as domain modeling (h/t @whitequark).

Let’s say you have a bunch of raw data that has some sort of underlying structure, and you want to make sense out of it. If your data can be fit into well-known structures like Merkle trees or directed acyclic graphs, it can be used to build high-quality, high-performance tools and systems. The central thrust of my career has been about doing just that.


I build tools that make developers’ lives better. I’ve spent many years doing it, and I’ve come away with a few core beliefs:

  1. Tools are force multipliers created by humans to serve humans. The ability to build and compose tools is among humanity’s greatest strengths.
  2. The digital realm opens up new possibilities for tools, free from physical constraints.
  3. Tools shape culture: if a tool makes something easier to do, people will do more of it.
  4. If a human has trouble understanding a tool, it is always a problem with the tool—never with the human.
  5. The material relations around the development of tools have an outsized, underappreciated influence on human society.


I have over a decade of professional experience developing software from start to finish:

  • coming up with new ideas: creating new software designs, inventing high-performance algorithms, and designing novel data structures that solve complex scaling problems, both independently and leading team efforts
  • prototyping those ideas and rejecting the ones that don’t work out
  • communicating those ideas to teams of 4-100 people through presentations and design documents
  • expressing those ideas through code, primarily in Rust but also in Python, Hack and some C and C++
  • validating that code through a variety of techniques, including property-based testing and coverage-guided fuzzing, and driving efforts by large teams to do the same
  • and productionizing that code through thoughtful, staged rollouts, taking into account costs, risks and benefits along the way.

Everything I know I’ve learned by working in teams full of extraordinary people, and I owe a great debt of gratitude to them.


2018-present: I currently work at Novi on developer tools for the Libra blockchain. Before that I worked on the virtual machine for the Move smart contract language.

2012-2018: I worked on developer tools, primarily source control, at Facebook. As part of my work on Mononoke, I led a team effort to invent novel version control data structures that made performance-critical operations much faster.

2008-2012: while being a full-time student, I contracted for Mozilla on Firefox’s then-build system and Thunderbird, among other things.

Open source projects

I’ve been privileged to work on open source code for most of my career. Here’s a short list of projects I have substantial contributions to:

cargo-guppy: project lead for a set of tools and libraries that track Cargo dependency graphs. guppy is used by the high-security Libra project to solve a variety of problems, most importantly to understand what code ships in production binaries.

Libra: drove several systemic improvements to the Libra blockchain’s code quality, the biggest one being introducing property-based testing and coverage-guided fuzzing.

Mercurial: many improvements to the version control system: designing merge drivers, other new features, and performance work. Member of the steering committee from 2016-2018.

Mononoke: Founding member of the team that created Facebook’s next-generation source control server, now in production use (2019–).

  • Led a team effort to design Bonsai changesets, a Merkleized representation of source control data that has a significantly higher throughput than Git.
  • Implemented many core features, including wire protocol support for Mercurial, conversion to and from the Bonsai format, and lazy diff and merge algorithms that only fetch data as required.

Watchman: Integrated the file-monitoring tool with Mercurial. Making it reliable meant perfect tracking of file changes: found and fixed a number of TOCTTOU races in Watchman.


I’ve written tutorials about some of the more arcane parts of Rust in a literate programming style. These tutorials have been useful to learners in universities and corporations.

lifetime-variance-example: Covers the basics of variance in Rust, as it applies to lifetimes.

borrow-complex-key-example: How to implement the Borrow trait for non-trivial keys.


Available upon request.