Adam Chalmers

My year of reading Chinese history

2026-04-03T00:00:00+00:00

Last year I read a lot of Chinese history. I didn't expect to find it so interesting! China's history has now become a passion of mine. I want to tell you how I fell down this rabbithole, and why I stayed.

2025 reflections

2026-01-02T00:00:00+00:00

It's been a good year. We moved back to Austin from New Orleans, I've watched my first kid grow and develop and really start having a personality, and I've had a lot of fun at work.

I am 34

2025-11-16T00:00:00+00:00

This weekend I turned 34. When friends or family have birthdays, I like to ask them what they're excited for in the coming year. Today someone flipped the question on me, and this is what I answered.

2024 reflections

2025-04-01T00:00:00+00:00

Better late than never! It's been a really big year. My wife and I had our first baby, we moved to New Orleans (temporarily), I gave my first in-person conference presentation (at RustConf) then flew to Vienna for my second (EuroRust). And Zoo has grown massively. So it's been a fun but crazy year.

EuroRust 2024 talk: Code as contract as code

2025-01-01T00:00:00+00:00

A few months ago I was invited to EuroRust to talk about API servers and clients. When I worked at Cloudflare, I maintained a few API servers and the official Cloudflare Rust API client. There was a lot of toil and stress involved whenever the API servers changed: schemae had to be updated, and then so did clients.

When I joined Zoo I was very impressed to find that our CEO Jess Frazelle had already set up automatic schema generation from the API servers, and then automatic client generation from those schemae (in 4 different languages)! This made managing our API servers at Zoo MUCH easier than it was at Cloudflare.

So I wrote this conference talk aimed at my past self -- it's basically a guide on how to simplify your API operations. </iframe>

RustConf 2024 talk: Building a programming language for CAD

2025-01-01T00:00:00+00:00

Recently I gave my first-ever in-person conference presentation! I was invited to RustConf 2024 where I talked about why we're building KCL (KittyCAD language), a programming language for 3D design, at Zoo.dev.

The talk has three parts: background about computer-aided design (CAD) software and mechanical engineering, then why we built a programming language, then what I learned from the process and the gaps in existing compilers 101 education.

At some point I hope to expand this into a blog post, but until then you can just watch the video. </iframe>

My Developer Voices interview

2024-10-30T00:00:00+00:00

Kris Jenkins of Developer Voices</a> spoke to me on his podcast! We talked about KittyCAD and its language, which I'm building for my work at Zoo</a>.

You can listen to it wherever you get your podcasts, or watch it on YouTube. Thanks so much for having me on your podcast, Kris! Developer Voices has become my favourite tech podcast and I really love the range of people he talks to. Kris goes deep and is scared of getting into the technical nitty-gritty, unlike some other tech podcasts I've tried. I strongly recommend listening to his archive! </iframe>

I'm speaking at RustConf 2024!

2024-09-06T00:00:00+00:00

I'll be at RustConf 2024, speaking about KCL, the 3D manufacturing language we're building at Zoo.dev</a>! I'm really excited to present, and to meet a lot of other Rustaceans. If you're going to be in Montreal, send me a message or email (contact details here</a>) and let's make sure we say hi.

My Kitty terminal config

2024-05-29T00:00:00+00:00

I've been using Kitty</a> terminal for five years now, and I'm really happy with it. Recently I got curious about how to make it look prettier (inspired by all the beautiful terminals I see in some programmer subreddits). So, keep reading for a little explanation of my Kitty config file.

I also made a video showing how I configure a totally fresh Kitty terminal from nothing. </iframe>

But if you prefer text, keep reading.

Video: My VM and its time-travelling debugger

2024-03-22T00:00:00+00:00

My work at Zoo</a> has recently focused on KCL</a>, our CAD programming language. Currently our modeling app</a> uses a tree-walk interpreter, but for various reasons we've been exploring a proper compiler instead. I've been developing the compiler, called Grackle</a>. It compiles to a bytecode VM (i.e. an abstract machine), called the KCVM. I gave a 10-minute presentation about KCVM and its time-travelling debugger at a tech talk in Austin recently. Here's the recording!

Thanks very much to Jam.dev</a> for hosting the event! </iframe>

Free users are incredible

2024-01-02T00:00:00+00:00

Cloudflare has a really generous free tier, and it gets a lot of free users. I often see comments on Hacker News saying "Cloudflare must be doing something shady, so many people use it for free, and if you're not the customer, then you're the product". This is mostly wrong -- Cloudflare gets a lot of value from its free users, in normal, not-shady ways. Here's why it's helpful to have a ton of free users.

2023 reflections

2023-12-23T00:00:00+00:00

Thinking about the things I liked and some really fun career changes from the last 12 months.

Video: Error handling

2023-12-21T00:00:00+00:00

The fourth Rust Club video is up! Every Monday I teach Rust to my coworkers at zoo.dev</a> on video chat. We record the call and put it on YouTube so you can learn too. This week's video is about different ways to handle errors in Rust -- when should you panic and when should you return a Result::Err? And what type should that Result::Err be?
Apologies for the low video quality, starting from next episode we used a better-quality recording system. </iframe>

Video: Analyzing performance

2023-12-05T00:00:00+00:00

KittyCAD</a>'s third Rust Club video is up! We analyze how fast the demo parser from my [first video][/winnow-basics] is, and find ways to speed it up. We use benchmarks to measure its speed, and flamegraphs to visualize its runtime, to find places we can improve.
Apologies for the low video quality, I didn't know we'd be releasing this to YouTube, so it's just using Zoom's "record screen" feature. Starting from episode 5 we used a better-quality recording system. </iframe>

Investigating crazy compile times

2023-11-28T00:00:00+00:00

I hate long compiles. I spend hours of my time trying to reduce minutes of compile-time. I recently noticed that the KittyCAD Rust API client</a> was taking an incredibly long time to compile in release mode. Weirdly, the compile time in debug mode was totally fine. I managed to shrink the release compile-times from 33 minutes to 1.5 minutes. Here's how.

Video: Parsing a programming language

2023-11-22T00:00:00+00:00

KittyCAD</a>'s second Rust Club video is up! My [first video][/winnow-basics] covered the Winnow</a> library for parsing text. Today's video shows you a real-world parser example. I'm working on the KittyCAD language (KCL) for designing CAD models, and this reviews the tokenizer and parser I wrote recently.
Apologies for the low video quality, I didn't know we'd be releasing this to YouTube, so it's just using Zoom's "record screen" feature. Starting from episode 5 we used a better-quality recording system. </iframe>

Interviewed at Filtra.io

2023-11-04T00:00:00+00:00

I had a great time talking to Drew of filtra.io</a>! We talked what KittyCAD does and why we're all-in on Rust. We also get into my past at Cloudflare and why there's so much Rust there. Check out the piece here</a>.

Video: My P99Conf talk on Rust backends

2023-10-19T00:00:00+00:00

I had a great time presenting at P99Conf</a>! I watch their talks every year and I always learn a lot. I was really thrilled to present a talk at this year's conference. It's heavily based on my blog post Why use Rust on the backend?</a>. If you missed the talk, you can watch the recording or view the slides here</a>.

Video: Parsing text with Winnow

2023-10-19T00:00:00+00:00

I work at KittyCAD</a>, and every Monday I teach Rust to my coworkers for an hour. We always record them, so that over time we build up an archive of Rust learning videos. Recently I realized we should put some of them on the internet, because other programmers outside KittyCAD might find them helpful too!
This is our first episode, and it's about building parsers with Winnow</a>, a new fork of Nom. I'm a big fan of Nom, and I've written about it a lot</a>. I've been interested in Winnow since it was announced</a>, so here's an hour-long explanation of how to use Winnow.
Apologies for the low video quality, I didn't know we'd be releasing this to YouTube, so it's just using Zoom's "record screen" feature. Future episodes should have higher video quality! </iframe>

Rustconf 2023 recap

2023-10-02T00:00:00+00:00

I got back from Rustconf 2023 last week, and I had a great time! I thought I'd write up my impressions of the conference, for anyone curious about what it's actually like.

Missed opportunities for git aliases

2023-06-19T00:00:00+00:00

I don't pair program very often, but sometimes when you're stuck on a really annoying problem, it can be helpful to have a coworker looking over your shoulder. My new job is fully-remote, so we occasionally screenshare when someone's stuck. One of my favourite things about pair programming is that I get to see the little idiosyncrasies of everyone's workflow. For example, you notice which peers use vim for everything, and pick up on all their awesome little keybindings to jump around the document. Or you realize that one peer has installed a bunch of awesome VSCode extensions that you can steal.
Several coworkers have remarked that I use shell aliases way more often than them! For example, I mostly work with rust, so I used alias c="cargo"</code> to tell my shell "when I type c</code>, replace it with cargo</code>". Then I use Cargo's built-in aliases, e.g. cargo check</code> and cargo c</code> are equivalent. So, when I want to run cargo check</code> I just type c c</code> and my shell expands it to cargo c</code> and Cargo expands it to cargo check</code>. My coworkers were very amused by this! I think a suite of nice, easy aliases can really save you time and avoid interrupting your flow state</a>. I'm trying to use more aliases for common tasks, and here's how I've been doing it.
Introduction to HTTP Multipart 2023-04-25T00:00:00+00:00 Multipart, or "form-encoded data", is something I see everywhere but never had to actually understand or use myself, because HTTP libraries handled it for me. Recently, though, I had to dive deeper into how multipart works, because it's pretty important at both Cloudflare and my new job at KittyCAD. Used correctly, multipart makes your file uploads faster and use less memory. I'm going to explain how it works, at a high level, so you'll recognize when you could use it to save time and memory in your HTTP servers/clients. Why use Rust on the backend? 2023-03-19T00:00:00+00:00 I read and liked Andrew Israel's I love building a startup in Rust. I wouldn't pick it again.</a> It makes a lot of sense! He basically says that his startup prioritizes developer productivity over performance. Sensible choice for a start-up founder to make. If Rust is going to slow your developers down, and you don't need its benefits, then you should definitely consider using a different language. On the other hand, I've been using Rust as high-level language at Cloudflare for a few years now. By "a high-level language" I mean one where performance doesn't really matter much. I've mostly been using it for API servers, where overall latency doesn't really matter too much. I'd be totally fine using a garbage collected language, or an interpreted language, because I don't need to eke out every last microsecond for blazing fast performance. I just want my server to stay up, do its job, and let me ship features quickly. So why use Rust for a task like that? Well, although Rust has a reputation for being a low-level systems language, it actually does an admirable job of acting like a high-level language. So here's my list of reasons to consider using Rust, even for a project where performance isn't critical. I'm on Rustacean Station 2023-02-07T00:00:00+00:00 Hi all! Allen Wyma of Rustacean Station</a> had me on the podcast to talk about Rust at Cloudflare. We cover why and how Cloudflare started using Rust, how my team specifically works with Rust, and how Cloudflare works. We also go on a big tangent about social security numbers. Give the episode</a> a listen if you'd like. Signals vs. Servers 2023-02-06T00:00:00+00:00 Say you're running a long-lived program, like a server. Let's say the server needs to read some files from disk, like certificates or keys. Every so often, the certificates change, so your server has to reload them. How do you tell the server to reload those files? The traditional way is to use Unix signals. Your server listens for a particular signal, like SIGUSR1</code> (user-defined signal #1) or SIGHUP</code> (hangup signal), and can execute whatever code you programmed in when the signal is received. So, your code waits for the appropriate signal, receives it, then reloads the certs. This approach works fine, but it has some usability problems that came up at work. So, my coworkers have been thinking about better ways to do this. I wanted to blog about one such way, and see if anyone has better ideas. 2022 reflections 2023-02-05T00:00:00+00:00 Reflecting on the things I liked in 2022. I started writing this in December 2022 and completely forgot to finish it until February next year. Illegal satire about Rust 2022-11-11T00:00:00+00:00 In case you didn't hear, comedy is now legal on Twitter</a> but accounts engaged in parody must include “parody” in their name, not just in bio</a>. Of course, this only made everyone double down</a>. So yesterday, I changed my name to Rust Language and started posting misinformation. </a> The last week on twitter has basically been "the new 3rd grade substitute teacher can't control the class" and we're all misbehaving. I've changed my twitter</a> back to my real name and face, so I've preserved my fake Rust tweets for posterity here. Solving common problems with Kubernetes 2022-10-09T00:00:00+00:00 I first learned Kubernetes ("k8s" for short) in 2018, when my manager sat me down and said "Cloudflare is migrating to Kubernetes, and you're handling our team's migration." This was slightly terrifying to me, because I was a good programmer and a mediocre engineer. I knew how to write code, but I didn't know how to deploy it, or monitor it in production. My computer science degree had taught me all about algorithms, data structures, type systems and operating systems. It had not taught me about containers, or ElasticSearch, or Kubernetes. I don't think I even wrote a single YAML file in my entire degree. I was scared of ops. I was terrified of Kubernetes. Eventually I made it through and migrated all the Cloudflare Tunnel infrastructure from Marathon to Kubernetes. I didn't enjoy it, and I was way over my deadline, but I did learn a lot. Now it's 2022, and I'm leading a small team of engineers, some of whom have never used Kubernetes before. So I've found myself explaining Kubernetes to them. They seemed to find it helpful, so I thought I'd write it down and share it with the rest of you. This article is aimed at engineers who need to deploy their code using Kubernetes, but have no idea what Kubernetes is or how it works. I'm going to tell you a story about a junior engineer. We're going to follow this engineer as they build a high-quality service, and when they run into problems, we'll see how Kubernetes can help solve them. Hopefully this will get you comfortable building your own services in k8s! Static streams for faster async proxies 2022-08-26T00:00:00+00:00 Last week in Tokio's Discord chat server</a> someone asked a really interesting question: how can you stream a multipart body from an incoming request into an outgoing request? My struggle to answer this really helped me understand Rust async lifetimes. We'll explore why this is tricky, then design and benchmark a solution. What are Rust's HTTP extensions? 2022-07-24T00:00:00+00:00 I learned about extensions when reading the hyper docs</a>. But they also pop up in lots of other Rust web libraries, like http</a>, tonic</a>, and actix-web</a>. So they must be really useful, if so many libraries offer them. But I personally had no idea what they were or how to use them. Today I'm going to explain what extensions really are (a set of values, keyed by type), and how you can use them to pass data between different parts of your web servers (e.g. middleware, routers, and handler functions). I'll give you a real-world example from the gRPC server I'm building at my job. What I learned from making a DNS client in Rust 2022-04-10T00:00:00+00:00 Over the last few weeks I built my own DNS client</a>. Mostly because I thought dig (the standard DNS client) was kinda clunky. Partly because I wanted to learn more about DNS. So here's how I built it, and how you can build your own too. It's a great weekend project, and I learned a lot from finishing it. Parsing DNS headers with Nom 2022-03-11T00:00:00+00:00 In the last blog post, we learned how to parse binary, bit-by-bit</a> with Nom. I really wanted to give a real-world example of binary protocols, so here's one from Dingo</a>, a basic DNS client I made. Parsing bitstreams with Nom 2022-02-01T00:00:00+00:00 Programming languages generally only manipulate bytes (groups of 8 bits). It can be pretty tricky to manipulate single bits. But sometimes you need to -- for example, a DNS header</a> has some 4-bit numbers, and encodes some boolean flags into single bits. So we really need a way to parse binary data without chunking it up into bytes of 8 bits. Luckily, Nom</a> can do this! In the last blog post, we learned how to parse text files</a> with Nom. The trick is to start with simple parsers that parse a few characters at a time. Then, using combinators, combine those simple parsers into more complex parsers that can deserialize an entire structured file. We can reuse this approach for parsing binary data too. Let's see how! Parsing Text with Nom 2022-01-05T00:00:00+00:00 "Parsing" is turning a stream of raw text or binary into some structured data types, i.e. a Rust type that your code can understand and use. This isn't the textbook definition of parsing, but damnit, this is my blog and my opinion. This tutorial is about nom</a>, my favourite Rust parsing library. It uses a parser combinator approach: you start writing tiny parsers that match, say, a single number or a character. These become building blocks for larger parsers, that match, say, a date or a phone number. By combining many small parsers together, you can build a big parser that decodes a file or stream into nice Rust structs and enums. In this tutorial we'll use Nom to parse the input file to an Advent of Code</a> puzzle. Pin, Unpin, and why Rust needs them 2021-08-23T00:00:00+00:00 Using async Rust libraries is usually easy. It's just like using normal Rust code, with a little async</code> or .await</code> here and there. But writing your own async libraries can be hard. The first time I tried this, I got really confused by arcane, esoteric syntax like T: ?Unpin</code> and Pin<&mut Self></code>. I had never seen these types before, and I didn't understand what they were doing. Now that I understand them, I've written the explainer I wish I could have read back then. In this post, we're gonna learn What Futures are</li> What self-referential types are</li> Why they were unsafe</li> How Pin/Unpin made them safe</li> Using Pin/Unpin to write tricky nested futures</li> </ul> Grids in Rust, part 2: const generics 2021-03-24T00:00:00+00:00 In part one</a>, we defined a Grid trait and implemented it using 1D and 2D vectors. Benchmarks revealed that a 1D vector was a better choice than a nested 2D vector. In this post, we'll write a new implementation that uses arrays instead of Vec. This should be faster! Grids in Rust, part 1: nested vs. flat Vecs 2021-03-22T00:00:00+00:00 While making a raytracer in Rust</a>, I needed an efficient way to store the pixels of a 2D image. In this post, we'll compare two different implementations of a 2D grid datatype, dipping our toes into data parallelism with Rayon and benchmarking with Criterion.