ezyang's blog

the arc of software bends towards understanding

Archives

Years

Categories

All Articles

2026

Silent BC Breaking Changes March 2
Vibe Coding Design Study: tlparse February 3
Replicate Forwards, Partial Backwards February 3
DTensor erasure February 1
The JAX sharding type system January 28
Global vs Local SPMD January 27
Megatron via shard_map January 26
Computing sharding with einsum January 25
Hugo Migration January 4
The gap between a Helpful Assistant and a Senior Engineer January 4

2025

Code review as human alignment, in the era of LLMs December 20
Learning to love mesh-oriented sharding December 8
Draw high dimensional tensors as a matrix of matrices October 25
So you want to control flow in PT2 September 5
The Parallelism Mesh Zoo August 30
You could have invented CuTe hierarchical layout (but maybe not the rest of it?) August 22
State of torch.compile for training (August 2025) August 13
Vibe coding case study: ScubaDuck June 2
Why you should maintain a personal LLM coding benchmark April 4
New Years resolutions for PyTorch in 2025 January 9

2024

Ways to use torch.export December 23
Ways to use torch.compile November 5
Tensor programming for databases, with first class dimensions October 14
What's different this time? LLM edition October 4

2021

Interactive scraping with Jupyter and Puppeteer November 23
PyTorch Developer Podcast May 5
Rage bug reporting April 25
The PyTorch open source process January 6

2020

The hidden problem(?) with basic block procedures in SSA October 24
Idiomatic algebraic data types in Python with dataclasses and Union October 14
Let's talk about the PyTorch dispatcher September 10
Dynamic scoping is an effect, implicit parameters are a coeffect August 27
A brief taxonomy of PyTorch operators by shape behavior May 6
vmap in Haskell January 29

2019

PyTorch internals May 16
A short note about functional linear maps May 15
Microsoft Surface Book 2 March 17

2018

HIW'18: Let’s Go Mainstream with Eta! September 23
A year into Backpack July 14
A compile-time debugger that helps you write tensor shape checks April 6
Online/offline continuous integration March 12
Semantic Import Versioning in the wild February 23

2017

Systems ML workshop panel December 8
Accelerating Persistent Neural Networks at Datacenter Scale (Daniel Lo) December 8
MOCHA: Federated Multi-Tasks Learning (Virginia Smith) December 8
A Machine Learning Approach to Database Indexes (Alex Beutel) December 8
Ray: A Distributed Execution Framework for Emerging AI Applications (Ion Stoica) December 8
Backpack for deep learning August 17
Proposal: Suggest explicit type application for Foldable length and friends March 21
Prio: Private, Robust, and Scalable Computation of Aggregate Statistics March 17
Designing the Backpack signature ecosystem March 11
How to integrate GHC API programs with Cabal February 8
Try Backpack: Cabal packages January 17

2016

A tale of backwards compatibility in ASTs December 31
Backpack and the PVP December 30
Left-recursive parsing of Haskell imports and declarations December 21
The problem of reusable and composable specifications December 17
Thoughts about Spec-ulation (Rich Hickey) December 16
Try Backpack: <code>ghc --backpack</code> October 10
Seize the Means of Production (of APIs) September 13
The Base of a String Theory for Haskell September 7
The Edit-Recompile Manager September 2
Backpack and separate compilation September 1
cabal new-build is a package manager August 29
Optimizing incremental compilation August 27
What Template Haskell gets wrong and Racket gets right July 18
Debugging tcIfaceGlobal errors in GHC: a study in interpreting trace output May 15
Announcing cabal new-build: Nix-style local builds May 2
Hindley-Milner with top-level existentials April 24
ghc-shake: Reimplementing ghc --make January 7

2015

The convergence of compilers, build systems and package managers December 7
What is Stateless User Interface? November 27
Is no-reinstall Cabal coming to GHC 8.0? September 18
Help us beta test "no-reinstall Cabal" August 29
Ubuntu Vivid upgrade (Xmonad) May 29
Width-adaptive XMonad layout May 2
An Eq instance for non de Bruijn terms January 30

2014

Unintended consequences: Bound threads and unsafe FFI calls December 8
Ubuntu Utopic upgrade (Xmonad) December 4
Tomatoes are a subtype of vegetables November 14
Haskell Implementor's Workshop '14 September 7
Open type families are not modular September 4
A taste of Cabalized Backpack August 26
The fundamental problem of programming language package management August 21
What's a module system good for anyway? August 9
New theme! July 26
Type classes: confluence, coherence and global uniqueness July 11
Parsec: "try a <|> b" considered harmful May 17
GHC and mutable arrays: a DIRTY little secret May 9
Elimination with a Motive (in Coq) May 7
The cost of weak pointers and finalizers in GHC May 4
Calculating Shanten in Mahjong April 1
Haskell for Coq programmers March 17
Equality, roughly speaking January 30
How to maintain a pristine copy of your configuration files January 20
PEPM'14: The HERMIT in the Stream January 17
Ott ⇔ PLT Redex January 13
When a lock is better than an MVar January 7
So you want to add a new concurrency primitive to GHC... January 1

2013

Two bugs in the borrow checker every Rust developer should know about December 17
Visualizing a block allocator October 30
Xmonad and media keys on Saucy October 27
If you're using lift, you're doing it wrong (probably) September 26
Of Monadic Fixpoints and Heap Offsets September 24
Induction and logical relations September 18
Cost semantics for STG in modern GHC September 7
Blame Trees August 12
OPLSS lecture notes July 29
No grammar? No problem! July 2
HoTT exercises in Coq (in progress) July 1
(Homotopy) Type Theory: Chapter One June 24
The AST Typing Problem May 28
Anatomy of an MVar operation May 19
HotOS "Unconference" report:<br />Verifying Systems May 14
Category theory for loop optimizations May 12
The Difference between Recursion & Induction April 27
Kindle is not good for textbooks April 15
A Zerocoin puzzle April 11
A classical logic fairy tale April 7
NDSEG April 5
Resource limits for Haskell April 2
The single export pattern March 31
The duality of weak maps and private symbols March 19
What is a membrane? March 15
Kindle Paperwhite notes January 30
The GHC scheduler January 28
NLP: the missing framework January 2

2012

Google Nexus 7 setup notes December 31
Metro Maps of the News December 13
Maildir synchronizing Sup December 1
Why can't I just be a little lazy? November 26
Functional Encryption November 25
Extremist Programming November 20
Plan 9 mounts and dependency injection November 8
hp/D3.js: an interactive heap profile viewer November 2
Ubuntu Quantal upgrade (Thinkpad/Xmonad) October 24
ACM XRDS: Jeff Dean profile October 22
Duality for Haskellers October 19
Hails: Protecting Data Privacy in Untrusted Web Applications October 16
Visualizing satisfiability, validity & entailment October 15
GET /browser.exe October 12
Generalizing the programmable semicolon October 3
Template project for GHC plugins September 28
"This is really the End." September 24
Unintuitive facts about Safe Haskell September 17
The Y Combinator and strict positivity September 12
So you want to hack on IMAP... August 31
OfflineIMAP sucks August 30
How OfflineIMAP works August 27
The Monad Reader: Issue 20 August 25
Applicative functors August 16
Practical Foundations for Programming Languages (first impressions) August 15
Is Haskell liberal or conservative? August 10
Two ways of representing perfect binary trees August 4
Polymorphic variants in Ur/Web July 29
Managing the server/client split in Ur/Web July 25
Secure multiparty Bitcoin anonymization July 20
Why verification results in higher quality code June 23
Thoughts on gamifying textbooks May 24
An Interactive Tutorial of the Sequent Calculus May 22
Ubuntu Precise upgrade (Thinkpad/Xmonad) May 18
What happens when you mix three research programming languages together May 16
Some thoughts about literature review May 13
How Ur/Web records work and what it might mean for Haskell April 20
Use the source, don't read it April 17
Reduce Ubuntu latency by disabling mDNS March 24
Visit month: Princeton March 20
Is it better to teach formalism or intuition? March 18
Visit month: University of Pennsylvania March 16
You could have invented fractional cascading March 5
Visualizing range trees February 26
Anatomy of "You could have invented..." February 23
Transcript of "Inventing on Principle" February 20
Travel: Spring 2012 Edition February 18
How to build DRM you can trust February 15
POPL January 28
Modelling IO: MonadIO and beyond January 24
monad-control is tricky January 23
Mystery Hunt and the Scientific Endeavour January 16
Problem Set: The Codensity Transformation January 7
Why iteratees are hard to understand January 4

2011

Bugs and Battleships December 19
How to build i686 glibc on Ubuntu December 18
Interactive Demo of Zero-Knowledge Proofs December 17
Accessing lazy structures from C December 15
Transparent xmobar November 28
Ubuntu Oneiric upgrade (Thinkpad/Xmonad) November 24
How to read Haskell like Python November 14
The new Reflections on Trusting Trust October 28
Obviously Correct October 24
Polyglot programming October 12
Why you shouldn't do a PhD in systems September 26
Let's play a game September 5
8 ways to report errors in Haskell revisited August 29
Joseph and the Amazing Technicolor Box August 23
Diskless Paxos crash recovery August 14
First impressions of module programming August 5
In-program GC stats redux August 3
Changes to IntMap August 1
Food-related functional humor July 29
BlockedIndefinitelyOnMVar July 27
From data type definitions to code July 25
Variant types and GADTs July 22
In-program GC stats for GHC July 20
Synthetic Git merges July 18
Parallelism to plug space leaks July 15
Facebook support for BarnOwl July 13
Grad School, Oh My July 11
Cambridge retrospective: History and Philosophy of Science July 8
A new vision for Mendeley July 6
IVar leaks July 4
Scheduling IVars July 1
The IVar monad June 29
Debugging compilers with optimization fuel June 27
Multi-monitor xmobar placement on Gnome June 24
A Year of Notebooking (Part 2) June 22
A Year of Notebooking (Part 1) June 20
A pattern for increasing sharing June 17
On type synonyms June 15
A Taxonomy of Socialization on the Internet June 13
Pinpointing space leaks in big programs June 10
Measurement, quantification and reduction June 8
What Philosophy of Science Can Say for Software Engineers June 6
The Cryptography of Bitcoin June 3
Bitcoin is not decentralized June 1
Chain Rule + Dynamic Programming <br />= Neural Networks May 30
An insufficiently lazy map May 27
If it has lots of comments, it's probably buggy May 25
Tail recursion makes your loops cleaner May 23
Computing function composition May 20
Anatomy of a thunk leak May 18
Space leak zoo May 16
Reified laziness May 13
Calling all space leaks May 11
Bindings and CAFs on the Haskell Heap May 9
How Aristotle got it Wrong<br />On the importance of conceptual frameworks May 6
Unraveling the mystery of the IO monad May 4
Haskell: Not pure enough? May 2
How the Grinch stole the Haskell Heap April 29
Functions produce the Haskell Heap April 27
Implementing the Haskell Heap in Python, v1 April 25
IO evaluates the Haskell Heap April 24
Evaluation on the Haskell Heap April 20
The Haskell Heap April 18
Mailbox: Advice for a sup first-timer April 16
Tracing the compilation of Hello Factorial! April 13
Bugs from using the wrong variable April 11
Hoopl: Dataflow analysis April 8
Type Kata: Local data type April 5
Hoopl: Dataflow lattices April 4
Hoopl guided tour: Base system April 1
GHC migrating to Git March 30
HTML Purifier 4.3.0 released March 28
Ely Cycles March 25
Interleaving stream processors March 23
The return of Hellenistic reasoning March 21
Spring Reading: 2011 edition March 18
On expressivity March 16
Someone is wrong on the Internet March 14
Many-valued logics and bottom March 11
Killer mutants attack (mutation gone wrong) March 9
Type Technology Tree March 7
Petri net concurrency March 4
The creation of a statically-typed functional programmer March 2
On cargo culting and hacking February 28
Multi-day debugging February 25
Ad hoc approximations February 23
Semi-automatic testing February 21
Two short tips for FFI bindings February 20
On checked exceptions and proof obligations February 18
Picturing Hoopl transfer/rewrite functions February 16
Picturing binomial coefficient identities February 14
Android 2.x Sensor Simulator February 11
A suggestion for indent/php.vim February 9
Lav'net is watching you February 7
OCaml gotchas February 4
All about MVars February 2

2010

A year of blogging December 31
Greetings from Switzerland December 29
No one expects the Scott induction! December 27
Thriller: Doing it for the thrills December 24
Travel advisory December 21
Generalization and vagueness in specifications December 20
Tourist by day, Blogger by night December 17
ω: I’m lubbin’ it December 15
Getting a fix on fixpoints December 13
Errata for gin and monotonic December 10
Gin and monotonic December 8
Hussling Haskell types into Hasse diagrams December 6
Talk Friday December 3
How I Learned to Stop Worrying and Love the ⊥ December 1
My first proof in Isabelle November 29
Reflexivity. Qed. November 26
Integer sequences every computer scientist should know? November 24
Is multiply-carry strongly universal? November 22
Cambridge potpourri November 19
Haskell.org committee November 17
It's just a longjmp to the left November 15
You are in a maze of twisty little passages, all alike... (a GHC hacking post) November 12
mod_fcgid 2.3 is broken (fixed in 2.3.6) November 10
Medieval medicine and computers November 8
DP Zoo Tour November 5
Dead Edward Day November 3
DP Zoo November 1
Intelligence is the ability to make finer distinctions: Another Haskell Advocacy Post October 29
Blog name changed... October 27
OCaml for Haskellers October 25
Don't Repeat Yourself is context dependent October 22
Purpose of proof: semi-formal methods October 20
Rapidly prototyping scripts in Haskell October 18
Existential type-curry October 15
Quote Day October 13
Why being a sysadmin will help you do Science! October 11
The HTML purification manifesto October 8
Abstraction without a concrete concept October 6
Why I am in Cambridge October 4
Tips for running a hackathon October 1
How to get answers from busy maintainers September 29
So long America! September 27
High performance monads September 24
Data is Code September 22
Tension of patch and tree version control September 20
Session types, subtyping and dependent types September 17
Evolution of a Shared Web Host September 15
Keyword arguments in Haskell September 13
Towards platform-agnostic interruptibility September 10
pthread_cancel on Windows September 8
Embracing Windows September 6
Annotating slides September 3
My type signature overfloweth September 1
Defining “Haskelly” August 30
Interrupting GHC August 27
abcBridge: Functional interfaces for AIGs and SAT solving August 25
Type Kata: Distinguishing different data with the same underlying representation August 23
Day in the life of a Galois intern August 20
Type kata: Controlled sharing of references August 18
What high school Algebra quizzes and NP-complete problems have in common August 16
Generalizing APIs August 13
A radical Hackage social experiment August 11
Paper Monday August 9
The Gateway Drug to Type Programming August 6
Tour of a distributed Erlang application August 5
Buffered streams and iteratees August 4
How to pick your string library in Haskell August 2
Suggestion box July 30
Delaying implicit parameter binding July 28
Reader monad and implicit parameters July 26
Managing foreign pointers effectively July 23
Pipelines and continuations July 21
System.Posix.Redirect July 19
Maximum matching deadlock solution July 16
Flipping arrows in coBurger King July 14
Graphs not grids: How caches are corrupting young algorithms designers and how to fix it July 12
Safety first: FFI and threading July 9
Groom: human readable Show for Haskell July 7
Little’s law July 5
MVC and Purity July 2
Call and fun: marshalling redux June 30
Thinking about talk June 28
Marshalling with get and set June 25
First steps in c2hs June 23
The secret to successful autogenerated docs June 21
Principles of FFI API design June 18
Well-founded recursion in Agda June 16
Setting up Cabal, the FFI and c2hs June 14
The Haskell Preprocessor Hierarchy June 11
Static Analysis for everyday (not-PhD) man June 9
AP Physics: Stuck in the concrete June 7
Databases are categories June 4
Bug boogie: Git and symlinks June 2
Punt the Prelude May 31
Use The Monoid: A worked example May 28
Bananas, Lenses, Envelopes and Barbed Wire <br>A Translation Guide May 26
Lazy exceptions and IO May 24
Upgrading to Ubuntu Lucid May 21
Class Reflections May 19
I Hate Patches: <br>Confessions of an Open-Source Developer May 17
Spring 2010: A Random Walk May 14
Refactoring Haskell code? May 12
Nested Data Parallelism versus Creative Catamorphisms May 10
Omnipresent Cabal May 7
Name conflicts on Hackage May 5
Design Patterns in Haskell May 3
Art. Code. Math. (And mit-scheme) April 30
Inessential guide to fclabels April 28
The Problem with xUnit April 26
Creative catamorphisms April 23
Association maps in mit-scheme April 21
Thoughts on discussion April 19
Dudamel visits MIT April 16
Inessential Guide to data-accessor April 14
Later Impressions of the VX-8R April 12
Diagramming in Xournal and Gimp April 9
You could have invented zippers April 7
Cup of FP with a Java twist April 5
Summer internship at Galois April 2
More fun with Futamura projections March 31
The case of the Hash Array Mapped Trie March 29
Ad hoc wireless March 24
Hunting for abstractions in mathematics March 22
Mutation sleuthing in Python March 19
Haskell, The Hard Sell March 17
Straitjacket programming March 15
Five tips for maintainable shell scripts March 12
Replacing small C programs with Haskell March 10
Being an expert considered harmful March 8
How to use Vim's textwidth like a pro March 5
Third-party unattended upgrades in three steps March 3
Writing generator friendly code March 1
History as documentation February 26
The Art of Posing a Problem February 24
Comonads and Convolutions February 22
Type manipulation: Tricks of the trade February 19
Why we stay up late February 17
Hunting for constraints February 15
Scheming environments February 12
Sources of music February 10
Nested loops and exceptions (Oleg Kiselyov) February 8
Nested loops and continuations February 5
Classes begin February 3
Cute macro tricks in the kernel February 1
Workflows in Git: Single-user style January 29
Arcadia Rising posters January 27
To the right! Autocompletable names January 25
Hacking git-rerere January 22
Too many leftovers! January 20
Five advanced Git merge techniques January 18
Typeclasses matter January 15
Sup: Mail for Nerds January 13
First impressions of the VX-8R January 11
Why Haskell? The big question January 8
rxvt-unicode for gnome-terminal refugees January 6
Audio connectors and radios January 4
Adventures in Three Monads January 1

2009

2010: A Roadmap December 31
Iron Blogger December 28