• Oct 14, 2024 A Missing IDE Feature

• Oct 8, 2024 Two Workflow Tips

• Oct 6, 2024 On Ousterhout's Dichotomy

• Sep 24, 2024 The Watermelon Operator

• Sep 23, 2024 What is io_uring?

• Sep 6, 2024 Try to Fix It One Level Deeper

• Sep 3, 2024 The Fundamental Law Of Software Dependencies

• Aug 12, 2024 STD Doesn't Have to Abstract OS IO

• Aug 1, 2024 Primitive Recursive Functions For A Working Programmer

• Jul 25, 2024 How I Use Git Worktrees

• Jul 5, 2024 Properly Testing Concurrent Data Structures

• Jun 4, 2024 Regular, Recursive, Restricted

• Mar 22, 2024 Basic Things

• Mar 21, 2024 Zig defer Patterns

• Mar 2, 2024 Kafka versus Nabokov

• Feb 10, 2024 Window: Live, Constant Time Grep

• Jan 12, 2024 Write Less

• Jan 3, 2024 Of Rats and Ratchets

• Dec 31, 2023 Git Things

• Dec 31, 2023 O(1) Build File

• Dec 24, 2023 CI Dream

• Dec 21, 2023 Retry Loop

• Dec 10, 2023 Non-Send Futures When?

• Nov 16, 2023 IronBeetle

• Nov 15, 2023 Push Ifs Up And Fors Down

• Nov 7, 2023 Data Oriented Blogging

• Oct 23, 2023 Unified Versus Split Diff

• Oct 18, 2023 Unless Explicitly Specified Otherwise, Open Source Software With Users Carries Moral Obligations

• Oct 12, 2023 LSP could have been better

• Oct 11, 2023 UNIX Structured Concurrency

• Oct 6, 2023 What is an Invariant?

• Sep 13, 2023 Comparative Analysis

• Aug 17, 2023 TypeScript is Surprisingly OK for Compilers

• Aug 13, 2023 Role Of Algorithms

• Aug 9, 2023 Types and the Zig Programming Language

• Aug 6, 2023 Fantastic Learning Resources

• Aug 1, 2023 On Modularity of Lexical Analysis

• Jul 16, 2023 Three Different Cuts

• Jun 18, 2023 GitHub Merge Queue

• Jun 2, 2023 The Worst Zig Version Manager

• May 21, 2023 Resilient LL Parsing Tutorial

• May 6, 2023 Zig Language Server And Cancellation

• May 2, 2023 Value Oriented Programming Needs Implicits?

• Apr 23, 2023 Data Oriented Parallel Value Interner

• Apr 13, 2023 Reasonable Bootstrap

• Apr 9, 2023 Can You Trust a Compiler to Optimize Your Code?

• Apr 2, 2023 UB Might Be a Wrong Term for Newer Languages

• Mar 28, 2023 Rust Is a Scalable Language

• Mar 26, 2023 Zig And Rust

• Mar 8, 2023 An Engine For An Editor

• Feb 21, 2023 Why SAT Is Hard

• Feb 16, 2023 Three-State Stability

• Feb 12, 2023 <3 Deno

• Feb 10, 2023 How a Zig IDE Could Work

• Jan 26, 2023 Rust's Ugly Syntax

• Jan 25, 2023 Next Rust Compiler

• Jan 4, 2023 On Random Numbers

• Dec 31, 2022 Ray Tracer Construction Kit

• Nov 18, 2022 If a Tree Falls in a Forest, Does It Overflow the Stack?

• Nov 5, 2022 Accessibility: px or rem?

• Oct 28, 2022 Elements Of a Great Markup Language

• Oct 24, 2022 GitHub Actions Permissions

• Oct 19, 2022 Why Linux Troubleshooting Advice Sucks

• Oct 6, 2022 Hard Mode Rust

• Oct 3, 2022 From Paxos to BFT

• Jul 10, 2022 Almost Rules

• Jul 4, 2022 Unit and Integration Tests

• Jun 29, 2022 Notes on GATs

• Jun 11, 2022 Caches In Rust

• May 29, 2022 Builder Lite

• May 29, 2022 Binary Privacy

• Apr 25, 2022 Why LSP?

• Mar 26, 2022 Self Modifying Code

• Mar 14, 2022 RPATH, or why lld doesn't work on NixOS

• Nov 27, 2021 Notes On Module System

• Nov 7, 2021 Generate All the Things

• Sep 5, 2021 One Hundred Thousand Lines of Rust

• Sep 4, 2021 Fast Rust Builds

• Aug 22, 2021 Large Rust Workspaces

• Jul 30, 2021 ; echo Shell Injection

• Jul 10, 2021 It's Not Always ICache

• Jul 9, 2021 Inline In Rust

• May 31, 2021 How to Test

• May 12, 2021 Design Pattern: Kitchen Sink

• Apr 26, 2021 Concurrent Expression Problem

• Mar 22, 2021 Async Benchmarks Index

• Mar 12, 2021 Goroutines Are Not Significantly Smaller Than Threads

• Feb 27, 2021 Delete Cargo Integration Tests

• Feb 24, 2021 Another Generic Dilemma

• Feb 15, 2021 matklad @ NEAR

• Feb 14, 2021 For the Love of Macros

• Feb 10, 2021 A Better Rust Profiler

• Feb 6, 2021 ARCHITECTURE.md

• Jan 3, 2021 Two Kinds of Code Review

• Dec 28, 2020 Call Site Dependency Injection

• Dec 12, 2020 Notes On Lock Poisoning

• Nov 11, 2020 Why an IDE?

• Nov 1, 2020 Notes on Paxos

• Oct 15, 2020 Study of std::io::Error

• Oct 3, 2020 Fast Thread Locals In Rust

• Sep 20, 2020 Why Not Rust?

• Sep 13, 2020 Your Language Sucks, It Doesn't Matter

• Sep 12, 2020 Rust in 2021

• Aug 15, 2020 Code Smell: Concrete Abstraction

• Aug 12, 2020 Who Builds the Builder?

• Aug 11, 2020 Things I Have Learned About Life

• Jul 15, 2020 Two Beautiful Rust Programs

• Apr 15, 2020 From Pratt to Dijkstra

• Apr 13, 2020 Simple but Powerful Pratt Parsing

• Mar 22, 2020 Fast and Simple Rust Interner

• Feb 14, 2020 Why is Rust the Most Loved Programming Language?

• Jan 4, 2020 Mutexes Are Faster Than Spinlocks

• Jan 2, 2020 Spinlocks Considered Harmful

• Nov 16, 2019 A Better Shell

• Nov 13, 2019 rust-analyzer Blog

• Aug 23, 2019 Join Your Threads

• Jul 25, 2019 Unsafe as a Human-Assisted Type System

• Jul 16, 2019 Perils of Constructors

• Jun 20, 2019 Linux Desktop Tips

• May 19, 2019 Rust Course Retrospective

• May 19, 2019 Consider Using Asciidoctor for Your Next Presentation

• Jul 24, 2018 Exceptions vs Structured Concurrency

• Jun 18, 2018 A Trick For Test Maintenance

• Jun 6, 2018 Modern Parser Generator

• Jun 4, 2018 Newtype Index Pattern

• May 24, 2018 Typed Key Pattern

• May 4, 2018 Encapsulating Lifetime of the Field

• May 3, 2018 Effective Pull Requests

• Mar 3, 2018 Stopping a Rust Worker

• Jan 3, 2018 Make your own make

• Oct 21, 2017 Dynamic types in LLDB

• Mar 25, 2017 NixOS Notes

• Mar 18, 2017 Min of Three Part 2

• Mar 12, 2017 Min of Three