The Algebra of Loans in Rust

A Struct Sockaddr Sequel

Learn C++ Itanium Symbol Mangling

A Plan for 5-10%* Faster Free-Threaded JIT by Python 3.16

Frozen DuckLakes for Multi-User, Serverless Data Access

3x-9x Faster Apache Parquet Footer Metadata Using a Custom Thrift Parser in Rust

A Fork in the Road: Deciding Kafka's Diskless Future

Fast Call-Stack Backtrace

The macOS LC_COLLATE hunt: Or why does sort order differently on macOS and Linux (2020)

[Pre-RFC] Substructural Type System

Rethinking PostgreSQL buffer mapping for modern hardware architectures

Item Patterns and Struct Await

The Burrows-Wheeler Transform

CPU cache-friendly data structures in Go

The Time-Ordered ID and Base32lex Binary Encoding

Folding in Parallel

From Arc to Box: One Deref Bound to Rule Them All

Behind y-s2: serverless multiplayer rooms

Apply the Trie: Word Search

A DHT for iroh – Part 1, The Protocol

Monads Are Too Powerful: The Expressiveness Spectrum

Checking that functions are constant time with Valgrind (2010)

Building Search for this Site – Search on a static site

A Slotted Hash Cons for Alpha Invariance

Launching QuickDID – Fast, Open Handle Resolution for the AT Protocol

Driftsort: An efficient, generic and robust stable sort implementation

Areal, Are.na's new typeface

Cabinet: Dynamically Weighted Consensus Made Fast

Chunking for Fasta Parsing

In Order Traversal in Haskell and Rust

Building Bluesky comments for my blog

Zero-Copy (De)Serialization

Jujutsu UI

Destructive Updates – A Stitch in Time

SimdSketch: A Fast Bucket Sketch

Intensional Joy (a concatenative account of internal structure)

Ways to generate SSA

Systems Correctness Practices at AWS: Leveraging Formal and Semi-Formal Methods

Pwn2Own Automotive: Popping the Charx SEC-3100

Optics for UI 1: Deconstructing React with Parametrised Lenses

A Practical Interpretation of Linear Logic

Into CPS, Never to Return

Well-Typed Substructural Languages

Hacking physics from the back of a napkin (2020)

Dependent Types and the Art of HTTP Headers

The Rise of Bluesky

Scientific computing with confidence using typed dimensions

Reliable Immutable Transfer Protocol

OpenVMM – A New VMM for Windows and Linux, Written in Rust

Linearity in Query Processing

Hytradboi 2025

OpenBSD crond / crontab set_range() heap underflow (CVE-2024-43688)

Behind the Scenes on Type Directed Search for Unison Share

Abstract Interpretation in the Toy Optimizer

No More Tears, No More Knots: Arena-Allocated Trees in Rust

EGraphs as Ground Completion Talk and Egraphs 2024 Notes

Sans I/O when rubber meets the road

Identifying Leap Years (2020)

What does GCD have in common with leap years?

The FastLanes Compression Layout: Decoding >100B Integers per Second [pdf]

Spending too much time optimizing for loops

Inline caching in our AST interpreter

Knot-based Key Exchange protocol [pdf]

lsb2s – Ludicrous speed binary to source converter

Overflow in consistent hashing (2018)

Union vs. Sum Types

Building a Better Hashtable on an FPGA

Notes on Implementing Algebraic Subtyping

A small template engine for C

Modular Error Reporting with Dependent Lenses

Decoding UTF8 with parallel extract

Not all graphs are trees

Heartbeat Scheduling: Provable efficiency for nested parallelism

Lolita: A tagless, dependently typed, self-aware programming language

Unanimous 2PC: Fault-Tolerant Distributed Transactions Can Be Fast and Simple

Knuth–Morris–Pratt illustrated

Why is there no realloc that takes the number of bytes to copy?

Open-source XYZ nanopositioner for precision analytical applications

Rendering string diagrams recursively [pdf]

Gentle Intro to Type-Level Recursion in Rust: From Zero to HList Sculpting

Agave Font

Linear Algebra of Types (2019)

In Search of the Perfect Fold

Bertie – A minimal, high-assurance implementation of TLS 1.3 written in hacspec

Understanding the Phases Applicative

Faster and Fewer Page Faults

What's in a GIF?

Why Is Defunctionalization Good?

Evaluating the Claims of "SAT Requires Exhaustive Search"

A compact relocation format for ELF

QuePaxa: Escaping the Tyranny of Timeouts in Consensus

SuperC: Parsing All of C by Taming the Preprocessor [pdf] (2012)

TextOS – Twitter

Writing a scheduler for Linux in Rust that runs in user-space (part 2)