Tony Finch – link log

home
search
blog
links
feed
elsewhere

2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 latest

2025‑03‑20: Fear and loathing of the English passive.
2024‑10‑10: A modest proposal: C++ resyntaxed. (1996)
2025‑02‑14: Switching on strings in Zig.
2025‑01‑21: The hunt for EINVAL in embedded Rust.
2025‑01‑22: Mercator: Extreme.
2024‑12‑01: Why do we call it "boilerplate code?"
2023‑07‑28: The future of Clang-based tooling.
2023‑05‑31: Modern CPUs have a backstage cast of support cores.
2025‑04‑03: How Java got the generics it has, or, how I learned to stop worrying and love type erasure.
2024‑11‑20: Railroad time in the USA started on 18 November 1883.
2024‑10‑24: Linking directly to text fragments in web pages.
2025‑04‑11: What do bodies think about?
2024‑10‑24: Flatter wait-free hazard pointers.
2025‑03‑25: Database protocols are underwhelming.
2024‑05‑26: Hurl: an exceptional programming language.
2025‑03‑26: An epic treatise on error models for systems programming languages.
2023‑09‑30: SnapperGPS 2: a printed circuit board design for a snapshot GNSS receiver.
2021‑09‑21: Taming Golang’s memory usage.
2022‑12‑09: Using bitmaps to perform range queries.
2024‑05‑06: Pair your compilers at the ABI café.
2025‑03‑22: Imberbus: a classic bus service across the Salisbury Plain to the lost village of Imber.
2025‑02‑04: A developer’s philosophy.
2025‑04‑12: WebRTC for the curious.
2021‑10‑25: A prototype original iPod.
2025‑01‑20: Automatic server reloading on change in Rust with listenfd and systemfd.
2025‑02‑16: Spin: formal verification of multi-threaded code.
2024‑11‑13: Using portable SIMD in stable Rust.
2024‑12‑15: PopSec: how not to blow up a pipeline.
2024‑11‑19: The thing about the Kobayashi Maru.
2025‑04‑11: What is algebraic about algebraic effects and handlers?
2025‑02‑17: 0+0 > 0: C++ thread-local storage performance.
2024‑11‑08: The history of Standard ML ideas, principles, culture.
2021‑05‑03: What3Words: flaws in the algorithm.
2025‑01‑22: The London Underground is too hot, but it’s not an easy fix.
2022‑10‑18: Designing systematic colour schemes.
2025‑02‑07: Numbat: A statically typed programming language for scientific computations with first class support for physical dimensions and units of measure.
2024‑02‑03: A 3D mouse with 3D printed flexures and PCB coils.
2024‑12‑30: Adjust your sett: a tartan editor.
2025‑03‑27: RSS/Atom feed best practise.
2021‑08‑27: High performance correctly rounded math libraries for 32-bit floating point.
2025‑03‑31: sharun: run dynamically linked ELF binaries everywhere.
2024‑08‑16: How to write seemingly unhygienic and referentially opaque macros with Scheme syntax-rules.
2025‑01‑22: How to unlock LUKS using Dropbear SSH keys remotely in Linux.
2025‑03‑18: y-cruncher: a multi-threaded Pi program.
2024‑07‑26: Please stop calling databases CP or AP.
2022‑08‑05: C23 is coming: here's what's on the menu.
2025‑03‑11: Owi: performant parallel symbolic execution made easy with OCaml and WebAssembly.
2025‑02‑02: Hollywood: split a computer console into multiple panes of genuine technical melodrama.
2025‑03‑26: Build better Golang release binaries.
2021‑03‑05: The Black Death: marmots and Mongols?
2024‑08‑30: Bubble sort is not robust either.
2025‑03‑01: A dictionary of affixes: the building blocks of English.
2025‑03‑31: Policy for the distribution of ISO publications and the protection of ISO’s copyright: ISO POCOSA 2012.
2024‑09‑19: Ruby-SAML pwned by XML signature wrapping attacks.
2023‑12‑04: Wayland isn't going to save the Linux desktop.
2025‑01‑04: The state of Garnet in 2025.
2025‑03‑31: Incremental zero-config code navigation using stack graphs with tree-sitter at GitHub.
2024‑12‑04: Keyset cursors, not offsets, for pagination with PostgreSQL.
2024‑04‑29: Thorium nucleus excited with laser: a breakthrough after decades.
2024‑10‑03: Less htmx is more.
2021‑09‑14: Understanding pg_repack: what can go wrong, and how to avoid it.
2025‑01‑19: Hasochism: the pleasure and pain of dependently typed haskell programming.
2024‑11‑03: Rhombus: Racket’s new spin on macros without all the Scheme/Lisp parentheses.
2025‑03‑23: Carl Linnaeus's note-taking innovations.
2024‑11‑10: RISC-V vector extension overview.
2025‑03‑12: Constant-time code: the pessimist’s case.
2024‑11‑01: What is the point of an online conference?
2025‑03‑14: PAM unixsock.
2024‑11‑21: pv: pipe viewer progress bar.
2024‑03‑10: Learning lessons from the cyber-attack: British Library cyber incident review.
2024‑10‑25: A map of every road sign in the Netherlands.
2024‑11‑21: TIL: Some surprising code execution sources in bash.
2025‑01‑07: Building ultra long range TOSLINK.
2024‑06‑22: Overlays get ignored.
2024‑07‑16: Ethicswishing
2025‑03‑09: Performance of returning errors vs. exceptions in Go and C++.
2025‑01‑13: Underrated ways to change the world.
2025‑01‑25: World's first MIDI shellcode: remote code execution on a synthesizer.
2024‑12‑12: The Jujutsu version control system.
2022‑11‑18: Hardening unused mail domains.
2024‑10‑02: The fastest mutexes: Cosmopolitan libc and nsync.
2021‑06‑21: Finding the bottom turtle: bootstrapping from source.
2021‑08‑03: Working around a case where the PostgreSQL planner is "not very smart".
2025‑03‑28: Xee: a modern XPath and XSLT engine in Rust.
2024‑10‑18: ugrapheme: Unicode extended grapheme clusters in nanoseconds with Python.
2025‑03‑12: On the state of coherence in the land of type classes.
2021‑02‑18: 50 years of text games - 1977: Zork.
2024‑10‑30: Five or ten new proofs of the Pythagorean theorem.
2024‑12‑19: IPtables interactive diagram.
2024‑11‑12: What does f(x) mean in C++?
2021‑08‑10: Ultra-processed foods, diet quality, and health using the NOVA classification system
2025‑03‑31: There’s white stuff growing on your cheese that isn’t mold.
2024‑11‑07: Userland disk I/O.
2025‑02‑16: Gaussian random number generators.
2023‑05‑09: OmniPaxos: replicated state machine and consistent distributed log in Rust.
2024‑09‑11: We spent $20 and accidentally became the admins of .MOBI
2025‑02‑13: A fast 6502 code generator.
2022‑10‑14: Algorithms for modern hardware.
2025‑02‑08: Turner, Bird, O’Neill, and the sieve of Eratosthenes.
2024‑11‑19: Adding Apple’s 🌐 globe key to a QMK-powered keyboard.
2021‑11‑18: A simple, possibly correct, LR parser for C11.
2025‑02‑08: Colossus: the first large-scale electronic computer.
2024‑09‑23: KGT (Kate’s grammar tool): BNF dialect converter and railroad diagram generator.
2024‑06‑25: The magic of participatory randomness.
2025‑03‑09: Keep calm and panic: performance of errors in Golang.
2025‑02‑27: macOS tips and tricks.
2024‑07‑11: tview: a Golang terminal UI library with rich, interactive widgets.
2021‑06‑12: Designing Rust client bindings for REST APIs.
2024‑12‑21: The ugly truth about Spotify is finally revealed.
2024‑06‑18: Box plots are the better default choice for visualizing performance.
2024‑12‑05: The tragedy of Stafford Beer.
2025‑02‑03: Pinning down "Future is not Send" errors in async Rust.
2024‑08‑19: Don't repeat yourself and the strong law of small numbers.
2024‑11‑02: Strachey’s general purpose macrogenerator.
2024‑04‑23: A photo album of space age consumer electronics.
2025‑01‑16: The mess that is handling structure arguments and returns in LLVM.
2024‑05‑28: Your web API shouldn't redirect HTTP to HTTPS.
2025‑01‑16: COW vs BEEF: busting the biggest etymology myth in linguistic history.
2024‑10‑25: Bit twiddle hack: insert a 0 bit in the middle of a value.
2025‑03‑22: Brotli compression for the web.
2023‑12‑03: Monocypher 4: the clean break.
2021‑06‑20: Is Julia really fast?
2025‑01‑05: Don't clobber the frame pointer when writing asm for Golang.
2024‑08‑29: Kahan’s lecture notes on the status of the IEEE Standard 754 for binary floating-point arithmetic.
2025‑01‑31: Why is unauthenticated encryption insecure?
2025‑03‑16: Extracting content from an LCP “protected” ePub.
2025‑02‑22: Neut: a functional programming language with static memory management.
2023‑07‑29: Why is c the symbol for the speed of light?
2023‑07‑30: Serverless functions post-mortem.
2025‑01‑04: UltraLogLog: a practical and more space-efficient alternative to HyperLogLog for approximate distinct counting.
2025‑02‑14: Intensional Joy: a concatenative account of internal structure.
2025‑01‑13: The missing JIT tier for SQL query compilers.
2022‑09‑07: Wasmtime 1.0: a look at performance.
2021‑02‑18: Local privilege escalation exploit in Ubuntu apport crash handler.
2024‑04‑29: Principles for keyboard layouts.
2024‑06‑29: Programming advice I’d give to myself 15 years ago.
2021‑03‑12: Routing the technical interview.
2025‑01‑25: Advent of code 2024 in the BQN array programming language.
2023‑05‑23: How to include Git version information in a Golang binary.
2024‑10‑18: Understanding DNS resolution on Linux and Kubernetes.
2025‑01‑12: exec-path-from-shell: Make Emacs use the $PATH set in your shell.
2023‑02‑01: Surprises in the Rust JSON ecosystem.
2024‑10‑30: ANSI C89
2024‑10‑05: PostScript 1.0: a code study.
2025‑03‑21: Shaarli: personal, minimalist, super-fast, database free, bookmarking service.
2024‑06‑07: Leopard-free programming.
2021‑07‑05: The rise and fall of the OLAP cube.
2023‑11‑05: Ungrammar in Go and resilient parsing.
2025‑01‑14: Phil Rogaway on radical computer science.
2025‑01‑23: The mythical IO-bound Ruby on Rails app.
2024‑12‑03: Filtered sampling from sorted values with randomized binary search.
2025‑02‑09: blip: A tool for seeing your Internet latency.
2025‑02‑08: Tips for mathematical handwriting.
2025‑02‑15: Gorton: The hardest working font in Manhattan.
2025‑01‑11: Building Bauble: interactive signed distance functions with WebGL.
2024‑05‑09: datatype99: algebraic data types for C99.
2021‑05‑25: The unwritten contract of solid state drives.
2024‑11‑21: DBSP: automatic incremental view maintenance for rich query languages.
2025‑02‑09: Getting the type of a template argument as string in C++ without RTTI.
2025‑03‑14: Hash Chain: efficient exact online string search / matching through linked weak factors.
2024‑05‑29: Rhodes must fall: The legacy of Cecil Rhodes in the University of Oxford.
2024‑11‑17: Urban Machine: robotics and AI to reclaim lumber for reuse.
2023‑03‑15: Youtube2Webpage, if you much better from text than from videos.
2024‑06‑06: TPM GPIO fail: how bad OEM firmware ruins TPM security.
2021‑11‑09: Driftwood: know if private keys are sensitive.
2021‑02‑20: Siag: a spreadsheet based on X and Scheme in a grid.
2023‑12‑26: rscss: a reasonable system for CSS stylesheet structure.
2025‑02‑04: Delilah: Alan Turing’s secret wartime voice encryption project.
2024‑01‑02: LLM generated code is like particleboard.
2025‑01‑22: get_secrets: Negotiate symmetric secrets between two remote peers using mTLS secret exporter.
2023‑10‑21: Electromechanical refreshable Braille module.
2023‑12‑27: How America turned the tide in the cockroach wars.
2024‑11‑16: Nixie tubes.
2024‑08‑10: Rust on the RP2350.
2021‑02‑20: Reading with E-ink.
2025‑01‑06: Collatzeral damage: bitwise and proof foolish.
2021‑07‑05: The Turbo-Encabulator in Industry. (1944)
2023‑12‑31: How I forked SteamOS for my living room PC.
2025‑01‑13: Doug Lenat's source code for AM and EURISKO.
2021‑03‑18: The Nokia N900: the future that wasn’t.
2024‑06‑09: Ultrasonic investigations in shopping centres.
2021‑03‑26: The magical applications of zero-sized types in Rust.
2024‑11‑23: Why am I writing a JavaScript toolchain in Zig?
2021‑10‑19: Optimizations enabled by -ffast-math.
2025‑02‑27: Can Doom run it? Adding with NAND gates in Doom.
2025‑01‑06: Cray 1 supercomputer performance comparisons with home computers.
2025‑02‑28: Notes: long-form comments in GHC.
2023‑08‑21: Flex without the flex: bending FR4 PCBs.
2025‑03‑09: Performance of the Python 3.14 tail-call interpreter.
2021‑04‑04: Almquist shell (ash) variants.
2021‑10‑03: Fixing a Mac SE/30 to run A/UX.
2024‑10‑24: A line map for Milano's trams in TeX.
2024‑06‑13: Crafting an interpreter with Rust.
2025‑02‑08: From hours to 360ms: over-engineering a puzzle solution.
2024‑09‑26: Major leap for nuclear clock paves way for ultraprecise timekeeping.
2024‑11‑01: Unicode codepoints that expand or contract when case is changed in UTF-8.
2025‑02‑04: Notes on type layouts and ABIs in Rust.
2024‑07‑04: nq: a command line job queue utility.
2025‑01‑19: The surprising struggle to get a UNIX epoch time from a UTC string in C or C++.
2025‑02‑07: PolySubML: A simple ML-like language with subtyping, polymorphism, higher rank types, and global type inference.
2022‑05‑01: Sophie Wilson on the future of microprocessors. (YouTube)
2025‑02‑14: Type safe variadic printf in Idris.
2025‑01‑09: WorstFit: hidden transformations in Windows character sets.
2024‑12‑31: Optimizing static search trees in Rust.
2024‑09‑23: IO-Lite: a unified I/O buffering and caching system. (1999)
2024‑05‑15: Sir, there's a cat in your mirror dimension.
2021‑05‑28: The last days of Tokyo's Nakagin capsule tower.
2024‑01‑31: A homemade telephone exchange for rotary dial phones.
2024‑11‑19: In loving memory of the square checkbox.
2024‑06‑26: The many faces of undefined in JavaScript.
2024‑04‑04: CHERIoT and supply chain security.
2025‑02‑04: Decorator JITs: Python as a DSL.
2024‑12‑11: Making memcpy(NULL, NULL, 0) well-defined.
2024‑12‑21: Stacked error handling for large Rust projects.
2024‑11‑21: Handling cookies is a minefield.
2023‑05‑28: The silent (r)evolution of SAT.
2023‑12‑17: Lessons from implementing the Hurl programming language.
2025‑01‑12: Why I chose Common Lisp.
2021‑11‑24: Google cloud load balancer outage report.
2021‑02‑16: Arranging invisible icons in quadratic time.
2021‑07‑30: The Inter font family.
2024‑12‑25: When Unisys tried to cash in on GIF by charging royalties.
2024‑11‑11: Row major vs. column major arrays, row vectors vs. column vectors.
2021‑02‑27: 10 software engineering laws everybody loves to ignore.
2025‑03‑02: Hardware discovery: ACPI and Device Tree.
2025‑01‑04: FIFO queues are all you need for cache eviction.
2022‑11‑10: Anatomy of a scalable software transactional memory.
2024‑11‑20: Type safety back and forth.
2024‑11‑27: A collective of nouns.
2024‑10‑20: Responsive TOC leader lines with CSS.
2021‑02‑20: The beigeness, or how to kill people with bad writing: the Scott Alexander method.
2021‑08‑29: Caches, modes, and unstable systems.
2025‑02‑15: Unofficial Jepsen test of Patroni, a PostgreSQL high availability solution.
2025‑01‑10: Peter Kirstein describes how Britain got its first Internet connection.
2021‑04‑01: pg_auto_failover: PostgreSQL extension and service for automated failover and high-availability.
2025‑02‑01: Enabling Touch ID for sudo on macOS, before and after Sonoma.
2025‑02‑27: Socrates is a state machine: sans IO with async Rust.
2024‑11‑20: Ghosts of departed proofs. (functional pearl)
2025‑01‑09: dnsclay: DNS UPDATE/AXFR/NOTIFY to many custom DNS operator APIs gateway
2024‑10‑20: Using Euro coins as standard weights.
2024‑10‑01: Implementing virtual system calls with vDSO.
2022‑10‑04: What color is your markup?
2021‑12‑22: 34 at 34 for v5.34: Modern Perl features for Perl’s birthday.
2025‑02‑28: How CouchDB prevents data corruption with fsync.
2024‑10‑23: Our optimizers need a rethink.
2025‑01‑11: Rewrite it in Rust: a computational physics case study.
2025‑01‑20: Hash function design, SMHasher and Goodhart's Law.
2021‑06‑04: Post Office Trial: Marshall spells it out in a speech to University of Law.
2022‑10‑08: I have come to bury the BIOS, not to open it: The need for holistic systems.
2025‑02‑20: A tail calling interpreter for Python, and other musttail updates.
2024‑10‑06: A fast revese linear scan register allocator for Cranelift.
2024‑12‑30: Concurrent cycle collection for Scheme in Rust.
2023‑08‑22: Normalcy bias: it's not cool to overreact.
2024‑06‑29: Devops: the funeral.
2025‑02‑06: Thoughts after months of using Zig.
2024‑10‑21: A multithread concurrency cost hierarchy.
2021‑03‑04: Bitsquatting windows.com.
2024‑08‑27: Using dtrace on MacOS with SIP enabled.
2025‑02‑16: Program logics à la carte.
2021‑04‑29: Move constructors in Rust: is it possible?
2022‑12‑04: Leaving the basement: scaling up Mastodon at Hachyderm.
2025‑02‑07: Profiling in production with function call traces.
2023‑12‑11: How many lines of C it takes to execute a + b in Python.
2024‑11‑11: The CVM cardinality estimation algorithm.
2024‑04‑10: Steve Klabnik's Jujutsu tutorial.
2021‑08‑12: ZeroVer: 0-based versioning.
2024‑11‑11: Far too many ways to wait on a child process with a timeout.
2025‑02‑15: Gorton recreations.
2024‑04‑18: Formal mechanised semantics of CHERI C: capabilities, undefined behaviour, and provenance.
2025‑02‑17: How does Ada's memory safety compare with Rust’s?
2024‑10‑01: Kurt Vonnegut’s chess-like game GHQ.
2021‑05‑29: Really advanced Typescript types.
2024‑06‑15: Pitfalls of PostgreSQL logical decoding.
2024‑10‑21: The network is reliable? An informal survey of real-world communications failures.
2024‑06‑02: For want of a relative path to ld.so
2024‑09‑07: PERQ
2024‑12‑22: Blender USD scene import is accidentally quadratic.
2023‑12‑28: The heart of a language server.
2024‑12‑28: On Ada's dependent types, and its types as a whole.
2021‑08‑10: A security analysis of STARTTLS in email protocols.
2022‑01‑09: SSH agent restriction.
2025‑01‑08: Fidget: a library for representing implicit surfaces.
2023‑05‑29: Writing to the macOS clipboard the hard way.
2025‑01‑22: Compiler fuzzing in continuous integration: a case study on Dafny.
2025‑01‑17: Get a random selection of lines in a file using reservoir sampling in Rust.
2025‑02‑05: The Sudoku affair.
2024‑09‑24: A busy beaver Collatz coincidence.
2024‑11‑27: The capacitor that Apple soldered incorrectly at the factory in the Macintosh LC III.
2025‑02‑02: Introducing sealed capability types for CHERIoT.
2024‑10‑12: The ultimate conditional pattern matching syntax.
2023‑01‑06: A practical comparison of build and test speed between C++ and Rust.
2025‑01‑31: Byte queue limits for Linux network drivers.
2025‑01‑05: D2: declarative diagramming, implemented in Golang.
2024‑12‑04: Francis Crick’s central dogma of genetics is not a "dogma," and it has never been broken.
2024‑11‑09: Algol 68: a retrospective.
2024‑10‑05: The solid-state register allocator.
2025‑02‑02: Conway's law: how do committees invent?
2025‑01‑16: ipcc-downloader: download iOS cellular carrier profiles.
2025‑02‑16: Small-data computing: Hans-J Boehm’s correct calculator arithmetic.
2021‑10‑02: Are SSDs really more reliable than hard drives?
2024‑10‑06: London Transport 25: ride 25 different forms of transport in one day.
2024‑12‑05: Implementing async APIs for microcontroller peripherals in Rust.
2024‑12‑13: vale: A markup-aware linter for prose.
2021‑11‑11: The secret court case 50 years ago that robbed transgender people of their rights.
2025‑02‑03: A caveat with statically linked language runtimes.
2023‑10‑12: LSP could have been better.
2025‑01‑15: Fenwick trees are awesome!
2024‑10‑13: Silent CT: a quiet certificate transparency monitor.
2024‑10‑17: Discovering features using HTTP OPTIONS.
2024‑11‑02: Scuttlebutt protocol guide.
2025‑01‑01: How I helped fix sleep-wake hangs on Linux with AMD GPUs.
2023‑01‑23: Shaving cycles: faster log-linear bucketing.
2025‑02‑07: Periodic cooking of eggs.
2025‑01‑20: InAppBrowser.com: see what JavaScript commands get injected.
2024‑07‑02: Losing the world record in HATETRIS.
2025‑02‑08: Mustang: Rust programs written entirely in Rust.
2024‑09‑08: Cracking an old ZIP file to help open source the ANC's "Operation Vula" secret crypto code.
2021‑08‑16: A record type representation trick for Scheme.
2025‑01‑04: Phase behavior of Cacio e Pepe sauce.
2025‑01‑07: Zig's comptime is bonkers good.
2024‑10‑22: Mathics: a free, open-source alternative to Mathematica.
2025‑02‑11: An approach to generate correctly rounded math libraries for new floating point variants.
2024‑09‑24: Fully documented source code for Lander on the Acorn Archimedes.
2023‑12‑05: HTML: The Programming Language.
2022‑12‑26: Interval-based memory reclamation.
2024‑12‑11: No NAT November: a month without IPv4.
2025‑01‑12: From ASCII to ASIC: Porting donut.c to a tiny slice of silicon.
2024‑04‑18: UCAM-CL-TR-988: CHERI C semantics as an extension of the ISO C17 standard.
2021‑02‑26: 100+ interesting data sets for statistics.
2024‑12‑28: An open-source Wi-Fi MAC layer for the ESP32.
2022‑07‑12: predef: a wiki of pre-defined C compiler macros.
2025‑01‑02: The Fish of Theseus port from C++ to Rust.
2024‑11‑27: Emacs arbitrary code execution and how to avoid it.
2024‑06‑04: Codd almighty! 50 years of SQL.
2024‑03‑11: A practical unification of multi-stage programming and macros.
2024‑11‑07: Rust's sneaky deadlock with `if let` blocks.
2024‑11‑14: BetterBufRead: faster reads in Rust.
2024‑12‑15: Mutation XSS explained, with a CVE and a challenge.
2024‑11‑28: MIT aluminium bicycle project 1974.
2025‑01‑14: NREVERSAL of fortune: the thermodynamics of garbage collection.
2023‑12‑05: That's FAR-out, man: a kernel infoleak in Mac OS xnu.
2025‑01‑12: Backdooring your backdoors: another $20 domain, more governments.
2025‑02‑04: No-panic Rust: a nice technique for systems programming.
2024‑10‑10: Why we’re helping more wikis move away from Fandom.
2024‑08‑11: The tic-tac-toe mysteries of Xerloc O'Xolmes.
2024‑12‑17: Why did Silicon Valley turn right?
2024‑04‑11: Subclassing in Python, redux.
2024‑06‑28: gRPC: the bad parts.
2024‑05‑04: Interview with Donald Knuth, with his opinions on multicore CPUs.
2021‑05‑24: Back to the future: the story of Squeak, a practical Smalltalk written in itself.
2024‑10‑14: The beginnings of FM radio broadcasting.
2025‑02‑07: Rink: an open source unit-aware calculator.
2024‑06‑18: I’ve stopped using box plots. Should you?
2025‑01‑31: Adding garbage collection to our Rust-based interpreters with MMTk.
2024‑11‑21: The stereographic projection of the Stern–Brocot tree.
2024‑08‑31: Knepp rewilded.
2023‑12‑26: Fixing the TPM: hardware security modules done right.
2025‑01‑11: The double mmap() magic ring buffer.
2025‑01‑10: Pushing the whole company into the past on purpose: deploying leap second smear at Facebook in 2015.
2025‑01‑09: SQL NULLs are weird!
2023‑04‑16: Free Join: unifying worst-case optimal and traditional joins.
2024‑12‑10: Common misconceptions about compilers.
2024‑12‑01: DELETEs are difficult.
2021‑04‑02: DNS at IETF 110.
2024‑03‑06: Maybe everything is a coroutine.
2024‑06‑13: Understanding DNS in Kubernetes.
2021‑09‑22: Enumerating and analyzing 40+ non-V8 JavaScript implementations.
2021‑02‑28: Validating JSON input in Rust web services.
2024‑12‑21: A phantom memory leak that wasn't there.
2021‑04‑22: Starlink's high-speed satellite Internet: What's the catch?
2024‑11‑21: SQL, homomorphisms, and constraint satisfaction problems.
2023‑05‑06: The Austral programming language. (linear types and capability security)
2025‑02‑02: An interview with James H Wilkinson: early numerical methods with electronic computers.
2023‑02‑05: The BNF converter.
2023‑09‑19: OPK, Open Programmatic Keycap: a CadQuery model for spherical top keycaps.
2022‑08‑04: Animated explanation of a mechanical watch.
2024‑06‑12: Breaking AES-GCM on nonce reuse.
2021‑11‑11: Benchmarking symmetric encryption (AEAD) in Rust.
2024‑07‑27: Driving compilers.
2021‑09‑21: Full-stack sum types with TypeScript, Rust, and PostgreSQL.
2024‑08‑27: Don’t make fun of renowned author Dan Brown.
2022‑03‑08: HTML comments (kind of) work in JavaScript.
2025‑01‑31: Jujutsu VCS introduction and patterns.
2024‑07‑22: From recursive descent to LR via Pratt parsing.
2023‑07‑10: Can a Rubik's Cube be brute-forced?
2024‑11‑30: Everything you never wanted to know about linker script.
2024‑10‑15: The origin and pronunciation of "GHIBLI".
2025‑01‑31: Falsehoods programmers believe about null pointers.
2024‑12‑28: Von Neumann ordinals look like leaves.
2024‑10‑24: Zero or sign extend.
2024‑05‑02: Designing an efficient memory layout in Rust with unsafe and unions, or, an overlong guide in avoiding dynamic dispatch.
2022‑08‑30: Bit twiddling with Arm Neon: beating SSE movemasks, counting bits, and more.
2024‑11‑07: Bringing faster stack unwinding exceptions to Rust.
2021‑08‑19: malloc() vs mmap(MAP_SHARED) in multithreaded programs.
2024‑08‑03: There is (still) only one statistical test!
2023‑10‑03: A whirlwind tour of arm64 NEON vector instructions.
2024‑12‑05: Faster SQL pagination with keysets, continued.
2024‑09‑26: Rewriting Rust.
2024‑09‑10: Invisible salamanders are not what you think: AEAD’s lack of key commitment.
2021‑09‑05: Fast Rust builds.
2025‑01‑17: Responsible disclosure is wrong.
2025‑01‑15: Das Blinkenlights!
2024‑10‑28: The widely cited studies on mouse vs. keyboard efficiency are completely bogus.
2022‑12‑26: VBR: version based reclamation.
2024‑09‑18: Emptying the dishwasher With systems theory.
2024‑05‑09: ppstep: an interactive C/C++ preprocessor macro debugger.
2025‑01‑26: Use monoids for construction.
2024‑12‑21: Rules to avoid common extended inline assembly mistakes.
2024‑09‑15: AT&T’s CRISP Hobbits.
2024‑04‑08: Excuse me sir, would you like to buy a kilo of isopropyl bromide?
2024‑11‑20: Understanding the BM25 full text search algorithm.
2022‑06‑10: Cranelift’s Regalloc2, used by Wasmtime and Rust.
2021‑02‑25: Bilinear down/upsampling, aligning pixel grids, and that infamous GPU half pixel offset.
2024‑12‑16: Revisiting Hubris appconfigs.
2022‑03‑30: The shape of data.
2024‑08‑24: CORS is stupid: a guide to cookies and cross-origin request security.
2025‑01‑09: The design recipe from “how to design programs”.
2021‑07‑18: Do low-level optimizations matter?
2024‑06‑26: Why I attack.
2024‑12‑28: Ferris-on-Air: An experimental Wi-Fi stack for the ESP32 in Rust.
2024‑12‑23: diman: A Rust library for checking units of measure at compile time.
2021‑06‑23: Going beyond Ada 2022.
2024‑11‑08: Some proposals for improving the efficiency of ALGOL 60 — Strachey & Wilkes.
2022‑10‑08: The Bulgarian calendar.
2025‑01‑12: What do long-term prices tell us about mineral resource scarcity?
2024‑12‑01: Typst as a programming language.
2024‑11‑24: Petnames: A humane approach to secure decentralized naming.
2024‑10‑26: Before you buy a domain name, first check to see if it's haunted.
2025‑01‑06: Lord of the io_uring.
2024‑11‑03: RRB vector: a practical general purpose immutable sequence.
2024‑10‑18: French supreme court decides about museums’ secret 3D scans of their sculptures.
2024‑09‑22: The roots of Work-as-Done and Work-as-Imagined.
2024‑08‑31: CHERI myth: I don’t need CHERI if I have safe languages?
2025‑01‑05: Academic urban legends: spinach as a source of iron.
2024‑08‑14: spice: Fine-grained parallelism with sub-nanosecond overhead in Zig.
2022‑11‑16: git-branchless: High-velocity, monorepo-scale workflow for Git.
2025‑01‑11: Containerless plurals: separating number from type in object-oriented programming.
2024‑10‑21: Jujutsu (jj) in practice.
2023‑03‑07: I made React Native JSON.parse() 2x faster.
2024‑08‑12: Hard drive disassembly: an IBM Deathstar from Nov. 2000.
2024‑12‑16: Crash recovery in Exhubris.
2024‑07‑26: Color spaces: CIELAB, OKLAB, OKLCH.
2024‑03‑06: Use weird tests to capture tacit knowledge.
2024‑09‑28: The perils of transition to 64-bit time_t in Gentoo.
2024‑11‑29: Coded character sets history and development.
2024‑03‑27: Who killed the network switch? An embedded Rust debugging story.
2021‑10‑22: A floating point parser bug in MySQL left AWS WAF clients vulnerable to SQL injection.
2024‑10‑19: Clapping Music for two flip-disc displays.
2024‑10‑11: Safety goggles for alchemists: the path towards safer transmute in Rust.
2021‑06‑19: A tour of safe tracing GC designs in Rust.
2024‑08‑08: Kyua graduates: The story behind the FreeBSD and NetBSD testing frameworks.
2023‑10‑26: Technical documentation for Citus distributed PostgreSQL.
2024‑05‑13: How to include Git version information in a Golang binary.
2021‑07‑08: The state of Python packaging in 2021.
2023‑09‑19: mlego: DIY mechanical keyboards using LEGO enclosures.
2024‑03‑06: How I use git worktrees.
2025‑01‑04: 1ML: core and modules united.
2024‑12‑10: Gyroscopic Gyros.
2024‑06‑16: Generators vs list comprehensions with join() in Python.
2024‑09‑14: Speeding up Valkey to over 1M requests per second with memory prefetching.
2025‑01‑05: The evolution of tunnel boring machines.
2024‑07‑30: A skeptic's first contact with Kubernetes.
2021‑10‑05: Is this the simplest (and most surprising) sorting algorithm ever?
2024‑09‑23: An overview of cross-architecture portability problems.
2024‑03‑21: Bug hunting in btrfs.
2025‑01‑13: Accurate benchmarking: how to account for the loop overhead.
2024‑10‑20: QUIC is not quick enough over fast internet.
2025‑01‑13: Fluid simulation pendant.
2024‑03‑29: Could ice cream possibly be good for you?
2024‑05‑26: Extend your battery life with the scx_rustland Linux scheduler.
2024‑04‑20: Microsoft Windows denial of service by Hisense TV.
2024‑06‑24: Rust’s new sort algorithms.
2021‑12‑11: Rapidly rendering fractals on stupidly unsuitable machines.
2022‑12‑28: Capability computing at LLNL.
2022‑12‑26: Parallel sections: scaling system-level data-structures.
2021‑06‑11: How to make simple derive macros in Rust.
2022‑10‑04: Signals in prod: dangers and pitfalls.
2021‑04‑29: The case of the curiously slow shader.
2025‑01‑10: How to miscompile programs with “benign” data races.
2024‑09‑13: Energy after fire.
2021‑04‑12: Use console.log() like a pro.
2024‑10‑30: malloc(0) & realloc(…，0) ≠ 0
2023‑07‑27: The mind grenade, 50 years on.
2021‑02‑16: Earley parser.
2024‑12‑13: UNIX Review magazine interviews Larry Tesler.
2024‑08‑15: A LaTeX-typeset reproduction of Reynolds' "Types, Abstraction and Parametric Polymorphism".
2024‑09‑17: Watching letters: a history of Latvian orthography.
2024‑12‑16: Parse me, baby, one more time: bypassing HTML sanitizers via parsing differentials.
2024‑08‑17: MVCC: The part of PostgreSQL we hate the most.
2024‑10‑23: Breaking Bad: how compilers break constant-time cryptography implementations.
2024‑11‑10: The design of a self-compiling C transpiler targeting POSIX shell.
2021‑10‑21: PostgreSQL text search: balancing query time and relevancy.
2025‑01‑08: De-smarting the Marshall Uxbridge bluetooth speaker.
2024‑10‑10: Designing a fast concurrent hash table in Rust.
2021‑06‑13: Using black magic to make a fast circular buffer.
2024‑10‑04: Blessed.rs: an unofficial guide to the Rust crates ecosystem.
2024‑12‑04: OKLCH colour picker and converter.
2022‑03‑27: n2: revisiting the ninja build tool.
2024‑11‑29: Using Pandoc and Typst to produce PDFs.
2024‑11‑27: Structured editing and incremental parsing.
2021‑03‑11: Retrofitting effect handlers onto OCaml.
2021‑02‑20: Shaman: evaluate the numerical accuracy of a C++ application and locate sources of error.
2024‑05‑07: A 100x speedup with unsafe Python.
2024‑12‑19: Fetching RSS/Atom feeds respectfully with curl.
2024‑04‑13: Transcript of Martha Wells’ Jack Williamson Lecture 2024, on MurderBot.
2024‑09‑09: What is the best pointer tagging method?
2024‑08‑06: Building rqlite 9.0: cutting disk usage by half.
2024‑08‑15: A history of orthogonal frequency division multiplexing (OFDM).
2024‑09‑18: Database replication design spectrum.
2024‑11‑06: Mimic: a fast System/370 simulator for the IBM RT PC. (1987)
2024‑11‑17: Styling Graphviz with CSS.
2023‑05‑01: Perfect hashing for strings with PEXT.
2024‑09‑04: OptView2: inspect missed optimizations by LLVM clang.
2024‑12‑30: Revealing peanut butter overheads with flame graphs.
2024‑04‑04: The V8 sandbox.
2021‑04‑04: The new standard that killed the loudness war.
2024‑10‑18: The strange cases of consumer-grade routers on puny power supplies.
2024‑05‑17: The rainbow hats puzzle.
2024‑09‑02: Parsing awk is tricky.
2024‑11‑03: qcp: QUIC remote file copy.
2021‑06‑17: Speeding up message parsing by 3x to 10x by switching from serde to nom in Rust.
2024‑10‑31: C++ ABI compatibility: the day the standard library died.
2021‑06‑02: Leading through writing in software engineering.
2023‑11‑08: Surprising facts about new CSS selectors.
2024‑05‑28: TerminalTextEffects: a visual effects engine for xterm-compatible terminal emulators.
2024‑06‑09: How many High Streets are there in London?
2024‑06‑26: Rigorous numerical integration in Arb.
2024‑11‑23: copycat: intercept system calls using seccomp.
2021‑03‑02: LastPass Android app has seven trackers.
2021‑03‑11: How many PostgreSQL developers does it take to make jsonb subscripting work?
2021‑11‑29: What SRE is not.
2024‑08‑23: Speeding up serde_json strings by 20%
2023‑10‑20: Mandelbrot deep zoom theory and practice.
2021‑04‑04: Judah Levine on everyday time and atomic time.
2022‑02‑19: Bacon: background Rust code checker.
2024‑11‑21: Modern hardware for future databases.
2024‑09‑17: The centrality of stupidity in mathematics.
2022‑08‑08: High precision Maidenhead locators.
2021‑10‑16: Pink Floyd’s Young Lust telephone signalling explained.
2021‑09‑30: Lessons learned building an Oracle to PostgreSQL migrator.
2024‑11‑05: In search of types.
2024‑10‑02: TigerBeetle code style.
2022‑09‑05: USB, Thunderbolt, DisplayPort, and docks.
2024‑06‑11: Characterizing the Raspberry Pi Pico RP2040 ADC.
2022‑10‑05: Introduction to low level bit twiddling hacks.
2022‑11‑09: The influence of Self.
2024‑04‑29: Simple NDP proxy to route your IPv6 VPN addresses.
2024‑02‑22: What modern NVMe storage can do, and how to exploit it: high-performance I/O for high-performance storage engines.
2024‑10‑28: Old MacDonald had a barcode, E-I-EICAR.
2022‑09‑18: An X11 apologist tries Wayland.
2021‑12‑17: How not to learn Rust.
2021‑05‑25: Jerikan: a configuration management system for network teams.
2023‑05‑05: Science Fiction Movie Lettering
2024‑10‑08: Z.200 CHILL: the ITU-T programming language.
2024‑11‑10: The principles of Mr. Harrison's longitude clock / maritime chronometer.
2023‑01‑29: Elektročas HH3: the most accurate pendulum clock on the planet.
2021‑02‑21: AHash: a fast non-cryptographic keyed hash for in-memory hashmaps.
2024‑11‑26: A solution to the onion problem of J. Kenji López-Alt.
2024‑04‑29: WireGuard endpoints and IP addresses.
2021‑03‑06: An introduction to lockless algorithms in Linux.
2024‑11‑19: How many values does a boolean have?
2022‑07‑25: It’s time to leave the leap second in the past.
2024‑04‑29: fend: an arbitrary-precision unit-aware calculator.
2024‑12‑13: Things you never wanted to know about Golang interfaces.
2024‑12‑17: Murder mystery: GCC builds failing after sbuild refactoring.
2024‑11‑22: Syntax error recovery in parsing expression grammars (PEG parsers).
2023‑10‑02: 32 MiB working set on a 64 GiB machine.
2024‑10‑07: AVX bitwise ternary logic and the Amiga blitter.
2024‑12‑19: Please stop citing TIOBE.
2021‑11‑14: Debugging memory corruption on Windows: who the hell writes “2” into my stack?!
2024‑11‑01: ASCII control characters in the terminal.
2024‑03‑08: A flexible and economical UTF-8 decoder.
2023‑01‑17: BetterDisplay: extra configuration options for macOS.
2024‑12‑04: Egoless engineering.
2021‑10‑09: Finding bugs in database systems via query partitioning.
2023‑01‑19: Huge pages are a good idea.
2023‑11‑07: Reducing Raspberry Pi 5's power consumption by 140x.
2024‑12‑24: Safety vs performance in C, C++, and Rust sort implementations.
2024‑08‑29: Two Turkish i dots too many.
2024‑11‑21: Analytical anti-aliasing.
2021‑07‑29: Monkey Island PC speaker music player.
2024‑04‑30: A random walk through the Ada programming language.
2021‑06‑15: When graphs are a matter of life and death.
2024‑10‑07: A general model for the origin of allometric scaling laws in biology.
2024‑09‑10: Signatures are like backups.
2024‑06‑27: OpenSSL CVE-2024-5535: `SSL_select_next_proto` buffer overread.
2021‑06‑21: git undo: We can do better.
2023‑07‑22: Linear-time parser combinators.
2023‑11‑16: C++ std::source_location is broken.
2023‑03‑15: Infra-red in-situ (IRIS) inspection of silicon.
2024‑10‑04: Persi Diaconis: Why did Markov invent Markov Chains? (video)
2021‑02‑24: Adventures in stereograms.
2024‑07‑17: XSS injection using undeclared charset encoding and ISO-2022-JP sniffing.
2021‑03‑11: Returning iterators in Rust.
2024‑12‑16: OpenERV energy recovery ventilator.
2024‑11‑05: The Autocode programs developed for the Manchester University computers. (1958)
2024‑11‑02: The Lounge: a‎ modern, responsive, cross-platform, self-hosted web IRC client in TypeScript.
2024‑11‑01: CIL: C intermediate language, a front end for linters.
2021‑06‑21: Accidentally exponential behavior in Apache Spark.
2022‑11‑18: LEGO rolling ball clock.
2023‑12‑11: Compiling to categories.
2023‑08‑24: FreeBSD on Firecracker.
2024‑04‑04: Conway's Game of Life through time.
2021‑10‑13: A plug-compatible 100 MHz FPGA 6502.
2021‑05‑29: Joseph Weizenbaum's original ELIZA.
2024‑11‑27: Offpunk: an offline-first command-line web browser.
2024‑06‑29: Bytecode breakdown: unraveling Factorio's Lua security flaws.
2022‑11‑16: Who first thought of the notion of polynomial time? (featuring the Columbus principle)
2023‑04‑07: The longest straight line in Great Britain (without crossing a public road).
2021‑06‑13: A few thoughts on Fuchsia security.
2021‑12‑15: The Muppet Christmas Carol is the best adaptation of A Christmas Carol.
2023‑09‑23: Polonius revisited, part 1.
2024‑11‑08: CPL: failed venture or noble ancestor?
2024‑11‑27: if constexpr requires requires { requires } in C++.
2021‑09‑05: Why are a billion years of rock missing from the geological record?
2021‑07‑07: Extensions are moving away from the macOS kernel.
2021‑06‑04: Handling global associative arrays in PostgreSQL.
2024‑05‑12: Garbage collectors are scary.
2024‑07‑29: How to build highly-debuggable C++ binaries.
2021‑09‑30: squawk: a linter for PostgreSQL, focused on migrations.
2023‑11‑16: We don’t do DST at this company.
2024‑01‑03: SIEVE is simpler than LRU.
2024‑09‑03: Unmaking the Makefiles: exorcising the Rust compiler test suite one file at a time.
2021‑04‑03: Where is HTTP/3 right now?
2024‑11‑29: Slow networking between cloud VMs on the same host.
2021‑11‑29: Improving over-constrained Rust APIs.
2024‑11‑20: How did software get so reliable without proof?
2021‑07‑04: The dawn of formalized mathematics.
2024‑10‑28: What’s new in POSIX 2024 XCU commands and utilities.
2024‑03‑05: The "missing" graph datatype already exists. It was invented in the 1970s: relational algebra and datalog.
2024‑10‑04: "A=B", a book about computer methods of discovery and proof of hypergeometric identities.
2024‑09‑14: Porting SBCL to the Nintendo Switch.
2024‑06‑16: Reconstructing public keys from cryptographic signatures.
2024‑12‑04: Inheritance was invented as a performance hack in Simula.
2023‑11‑20: setenv() is not thread safe and C doesn't want to fix it.
2024‑11‑11: Type inference for units of measure.
2022‑03‑11: Implementing network time security (NTP NTS) at the hardware level.
2024‑09‑30: Beyond multi-core parallelism in Rust: faster Mandelbrot with SIMD.
2023‑05‑01: First clean water, now clean air.
2024‑09‑06: Massachusetts Bodged Transistor Authority: How we turned MBTA Red Line equipment into a car speedometer.
2024‑06‑13: Chaos in the medium: watercolour plotting.
2024‑05‑12: GPUs go brrr: how to keep the nVIDIA H100 tensor cores fed.
2024‑06‑27: Valve.Computer: A modern 8 bit design, built using 1950s thermionic valves.
2021‑04‑02: Ionica: how the British weather killed a billion pound tech company.
2021‑07‑07: Programming language memory models.
2024‑08‑29: Air Con: pay $1697 for an on/off switch, or fix the Android controller tablet?
2024‑08‑29: Rate limiting, ATM cells, and GCRA.
2024‑11‑28: Wislist for Linux from the mold linker's POV.
2024‑08‑03: Where do debuggers find shared library paths in core dumps?
2024‑11‑10: Formalising graphs with coinduction in Agda.
2021‑08‑19: The quest to recreate a lost and ‘terrifying’ medieval mead.
2021‑05‑12: Getting random rows very much faster with tablesample in PostgreSQL.
2024‑01‑02: What I've learned about flow fields for generative art.
2023‑01‑29: The 12-bit rainbow palette.
2024‑11‑11: Precise inference of expressive units of measurement types.
2022‑11‑30: Counting unique web site visitors without using cookies, UIDs, or fingerprinting.
2024‑08‑14: Incremental TT munchers: perhaps the most powerful macro parsing technique in Rust macro_rules.
2024‑11‑25: Theory-building and why employee churn is lethal to software companies.
2024‑11‑30: Combining git repos with josh-filter.
2022‑01‑27: Non-lazy futures considered harmful in Rust.
2024‑08‑24: Printing the web: HTML and CSS for paper books.
2021‑03‑18: Stealing arbitrary GitHub Actions secrets.
2024‑05‑02: Hobby’s algorithm for aesthetic Bézier splines.
2023‑04‑13: Mac keyboard layout configuration with hidutil.
2024‑04‑14: sotrace: show hidden dependencies in Linux binaries.
2024‑05‑18: Why writing correct software is hard.
2024‑05‑08: The C preprocessor iceberg.
2021‑04‑06: Eliminating data races in Firefox with thread sanitizer: a technical report.
2021‑07‑28: The fall of the SKI civilization.
2021‑03‑14: Fitting cubic Bézier curves.
2023‑08‑18: PolymurHash: a 64 bit universal hash function.
2024‑12‑04: The Hoare cube.
2023‑05‑31: Hacking my “smart” toothbrush.
2022‑11‑17: Who controls the Internet? A survey of authoritative DNS server diversity.
2023‑12‑27: A national evil: how iodized salt banished the curse of the goitre from Switzerland.
2021‑07‑29: One lost methyl group = huge amounts of food production.
2024‑04‑09: Concurrency vs paralellism.
2024‑11‑27: Chawan: a web browser for your terminal.
2024‑08‑13: Division, modulus, and remainder for computer scientists.
2023‑08‑13: Symmetry in Chaos.
2024‑11‑08: The mechanical evaluation of expressions: Landin on the lambda calculus. (1964)
2021‑09‑21: There was no formal methods winter.
2024‑04‑23: Inside the Super Nintendo cartridges.
2024‑10‑20: The origins of the term “daemon” in computing.
2024‑06‑01: Performance culture.
2022‑05‑25: You CAN average percentiles (if you know what you are doing).
2024‑11‑20: Map keys and lifetimes in Rust.
2024‑04‑23: The bubble sort curve.
2021‑06‑03: A new Protocol Buffers generator for Golang.
2021‑03‑30: The sixtyforgan: a Commodore 64 with a spring reverb; chiptunes like a church organ.
2024‑11‑01: Emacs org mode syntax cheat sheet.
2024‑11‑30: Compilation on the GPU? A feasibility study.
2022‑11‑11: Seeing through hardware counters: a journey to threefold performance increase.
2021‑09‑04: Linux tmpfs inode corruption: introducing inode64.
2024‑11‑04: A Hamiltonian circuit for Rubik's Cube.
2024‑06‑20: The full-source bootstrap: building from source all the way down.
2024‑06‑23: How to design a CPU ISA (instruction set architecture).
2021‑10‑24: Measuring C++ std::unordered_map badness.
2024‑04‑29: Bloat busters: pg_repack vs pg_squeeze.
2024‑11‑09: Texture-less GPU text rendering.
2021‑10‑11: Better operator precedence.
2024‑10‑17: C89 draft standard in HTML.
2024‑06‑01: Rust regex engine internals as a library.
2024‑11‑04: C++, complexity, and compiler bugs.
2024‑06‑10: Dangers of newlines in inline assembly.
2024‑08‑18: How OCaml type checker works, or, what polymorphism and garbage collection have in common.
2024‑10‑03: Terminal colours are tricky.
2024‑09‑27: Malicious SHA-1.
2022‑12‑26: Hyaline: snapshot-free, transparent, and robust memory reclamation for lock-free data structures.
2021‑11‑18: Getting started with Rust on a Raspberry Pi Pico.
2024‑03‑08: USAF computer security technology planning study: memory safety bugs in 1972.
2021‑02‑14: Guidelines for names in programming.
2024‑09‑18: Handling 8kHz raw mouse input on Windows.
2024‑05‑09: Scanners work fine over iSCSI.
2021‑08‑17: Behind the scenes at South Kensington tube station’s escalator replacement project.
2024‑11‑20: Nominal types for storing, structural types for manipulating.
2024‑09‑23: “Truly hygienic” let statements in Rust.
2021‑09‑21: Google Docs in a clean-room browser.
2023‑09‑27: ARM LDM and STM are Turing complete.
2024‑04‑18: Formal methods: just good engineering practice?
2021‑04‑22: Earth Restored: newly retouched photographs from the Apollo lunar missions.
2024‑07‑19: The GNU make jobserver Implementation.
2024‑08‑18: Techniques for safe garbage collection in Rust.
2024‑03‑04: Kubernetes failure stories.
2023‑01‑08: Production Twitter on one machine?
2023‑06‑22: 57 different scripts descended from Egyptian hieroglyphs.
2024‑06‑23: A history of Psion and Symbian.
2021‑03‑11: Notes from the DNS privacy workshop at NDSS 2021.
2024‑08‑27: Emulating x86 / amd64 on RISC-V.
2021‑06‑11: schemars: generate JSON schema from Rust code.
2022‑08‑04: C99 doesn't need function bodies: VLAs are Turing complete.
2024‑10‑11: Quantifying the Kevin Bacon game: a statistical exploration of Hollywood’s most connected actors.
2024‑10‑20: Better defunctionalization through lambda set specialization.
2024‑07‑04: The X window system at 40.
2022‑11‑20: Literature Clock
2024‑10‑22: A Mathematica interpreter in Typescript.
2021‑08‑31: APOLLO 68080: high performance 68k processor on FPGA.
2024‑04‑03: Cowgol: an experimental, Ada-inspired language for 8 bit micros.
2024‑03‑10: Compiling without continuations.
2024‑10‑09: SQLite's use of Tcl.
2024‑04‑05: Switching to the meow modal editing system from evil emacs.
2022‑03‑28: 3D printed Portal turret build guide.
2024‑10‑22: On the problem of naming things.
2022‑04‑30: Implementing a safe garbage collector in Rust.
2024‑11‑09: Known attacks and a primer on elliptic curve cryptography.
2021‑03‑16: Improving large monorepo performance on GitHub.
2021‑11‑26: The return of JavaScript for Mac OS automation, instead of AppleScript.
2022‑04‑25: Why LSP? On two-sided markets and N*M.
2021‑03‑04: Solving the structured control flow problem when compiling to WebAssembly.
2022‑05‑10: Hardening snmalloc.
2021‑09‑21: Index, a history of the.
2024‑11‑08: The main features of CPL. (1963)
2024‑04‑29: FreeBee: AT&T 3B1 UNIX PC emulator.
2024‑11‑05: Resurrection: the journal of the Computer Conservation Society.
2024‑09‑19: 20 years later, real-time Linux makes it to the mainline kernel.
2022‑11‑10: Why is Apple Rosetta 2 fast?
2021‑03‑18: 17 weird facts about the Hunspell dictionary format.
2021‑03‑04: Delete your Rust Cargo integration tests!
2024‑06‑04: Sound, precise, and fast abstract interpretation with tristate numbers.
2023‑05‑02: Flattening ASTs with arena allocation.
2024‑11‑02: Why PostgreSQL pg_dump is amazing.
2024‑09‑21: Questioning the criteria for evaluating non-cryptographic hash functions.
2021‑02‑18: Reconnecting your application after a Postgres failover.
2024‑09‑15: A time consuming vDSO pitfall for 32-bit code on arm64 Linux.
2024‑10‑22: Rustls outperforms OpenSSL and BoringSSL.
2024‑05‑06: JTAG hacking with a Raspberry Pi: introducing the PiFex.
2021‑06‑14: Let’s port Doom to an IKEA TRÅDFRI lamp!
2024‑10‑07: Octothorpes: hashtags for the open Internet.
2023‑04‑06: CAN Injection: keyless car theft.
2024‑11‑05: The official Aztec C online museum.
2024‑11‑01: ActivityBot: a simple ActivityPub bot server in PHP.
2023‑10‑14: Open Props: sub-atomic CSS.
2024‑10‑06: The Gleam programming language is pragmatic.
2024‑03‑09: SuperC: parsing all of C by taming the preprocessor.
2024‑03‑21: A giant leap for the leap second. Is humankind ready?
2024‑03‑23: Unexplanations: SQL is syntactic sugar for relational algebra. (not!)
2024‑10‑08: Five times ICANN deleted a ccTLD, and what it means for .io
2024‑06‑08: A fast alternative to the modulo reduction.
2021‑03‑05: Clojure from a Schemer's perspective.
2024‑04‑22: Manual for Larry Tesler’s PUB markup language. (1971)
2024‑06‑17: Making robots plan faster with SIMD and Rust.
2023‑01‑26: What time is it on the Moon?
2024‑10‑29: TCP SYN spoofing attack directs abuse complaints at Tor relays.
2024‑08‑27: 5000x faster CRDTs: an adventure in optimization.
2024‑10‑27: A new git-repack algorithm shrunk Microsoft’s Javascript monorepo git size by 94%.
2022‑07‑21: The origin of “Cry uncle!”
2024‑10‑05: Towards standards for handwritten zero and oh: much ado about nothing (and a letter). (1967)
2024‑06‑21: Reflections on software performance.
2023‑10‑17: Higher quality random floats.
2021‑11‑18: Mononym: type-level named values in Rust.
2024‑09‑25: A brief history of microprogramming.
2024‑10‑21: Learn Rust the dangerous way.
2022‑01‑03: Hacking a VW Golf power steering ECU.
2021‑08‑21: Index 1,600,000,000 keys with finite state automata and Rust.
2024‑04‑11: The simple beauty of XOR floating point time series compression.
2024‑06‑16: The story of reformatting 100k source files at Google in 2011.
2024‑04‑08: Putting out the hardware dumpster fire.
2024‑04‑29: Importing ECMAscript modules with require() in node.js.
2024‑09‑26: Attacking UNIX systems via CUPS.
2024‑11‑04: Macros, safety, and SOA (struct-of-arrays) in Rust.
2024‑09‑21: The working archivist's guide to enthusiast CD-ROM archiving tools.
2024‑03‑07: The CAP theorem: the bad, the bad, and the ugly.
2024‑10‑24: Why write a new RTOS for CHERIoT?
2024‑08‑31: Fortran dot/comma bug urban legend.
2024‑05‑27: Reclaiming IPv4 Class E 240.0.0.0/4.
2024‑10‑01: The case of the missing increment: Golden Cove twice as fast as expected?!
2021‑03‑06: Modern text features in R.
2024‑07‑22: Using algebra to refactor data types.
2023‑12‑05: Stop stealing sheep, and find out how typography works.
2022‑07‑13: Intel floating point reference sheet.
2024‑05‑07: Secure Randomness in Golang 1.22.
2024‑10‑02: Height hunt: a quest to find and visit every possible road vehicle height restriction sign in the UK.
2024‑02‑26: Tracing the baseband: cellphone modems.
2022‑12‑27: Reasons to ditch LastPass.
2023‑03‑12: How we knew space is a vacuum.
2021‑08‑14: Preprint déjà vu: a FAQ about the arXiv.
2021‑05‑23: GhostCell: separating permissions from data in Rust.
2023‑05‑14: rxv6: a Rust rewrite of MIT’S xv6 teaching OS.
2024‑05‑07: Search has been put in the vibe space.
2021‑03‑30: Hello, HPy.
2024‑03‑30: Xz format inadequate for long-term archiving.
2022‑11‑19: The truffle industry is a big scam. Not just truffle oil, everything.
2021‑11‑28: kmonad: an advanced keyboard manager.
2024‑08‑25: Old buildings in Cambridge.
2024‑05‑06: How to successfully rewrite a C++ codebase in Rust.
2024‑08‑01: What your web framework never told you about SQL injection protection.
2024‑05‑09: Needle: a DFA regex library that compiles to JVM bytecode.
2021‑12‑05: Async cancellation in Rust.
2024‑05‑18: Practical third-party library sandboxing with RLBox.
2024‑09‑17: Ratchets in software development.
2024‑09‑18: Bézier curve arc length parametrizations.
2024‑06‑08: Fibonacci hashing: the optimization that the world forgot (or: a better alternative to integer modulo).
2023‑11‑09: Interesting JavaScript bugs caught by no-constant-binary-expression in ESLint.
2024‑10‑07: Big ball of mud: the de facto standard software architecture.
2024‑08‑26: Writing a Rust compiler in C?!
2021‑06‑12: Do you really need Redis? PostgreSQL does queuing, locking, and pub/sub.
2024‑05‑12: The alternative programming language implementation problem.
2021‑03‑18: Algebraic graphs with class in Haskell.
2024‑06‑11: Forsp: a Forth+Lisp hybrid CBPV language.
2022‑09‑26: The curious design of skateboard trucks.
2024‑02‑18: Ten Python datetime pitfalls, and what libraries are (not) doing about it.
2022‑02‑01: Async embedded Rust vs FreeRTOS + C showdown!
2024‑02‑18: Smoothed asymptotics: from number theory to quantum field theory.
2024‑10‑28: OpenZFS deduplication is good now and you shouldn't use it.
2024‑05‑02: TestResult: a Rust error type that panics early.
2024‑10‑02: An introduction to the Filament hardware design language.
2024‑06‑18: Peak population projections.
2024‑09‑12: smolweb HTML specification
2021‑08‑17: The Wendelstein 7-X fusion stellarator proves its efficiency.
2022‑03‑18: Random number generator enhancements for Linux 5.17 and 5.18..
2021‑03‑26: Parallel Programming: Second Edition.
2023‑01‑24: Bounded flexible arrays in C.
2024‑10‑08: Tartufo searches through git repositories for high entropy strings and secrets.
2022‑11‑16: git-absorb: git commit --fixup, but automatic.
2024‑04‑28: Synth wars: The story of MIDI, the one interface that ruled them all.
2024‑10‑08: The origins of PostScript.
2024‑06‑02: Rust and dynamically-sized thin pointers.
2024‑05‑02: The world's loudest Lisp program, for tunnel evacuation.
2024‑08‑13: Good retry, bad retry: an incident story.
2024‑09‑15: Turning disposable vapes into a fast charge power bank.
2024‑05‑30: Ultrasonic cold brew coffee.
2024‑09‑09: Debunking CISC vs RISC code density.
2021‑05‑24: Counterexamples in type systems.
2022‑04‑10: The design of the RELAX NG XML schema language.
2023‑09‑18: Resilient LL parsing tutorial.
2023‑10‑23: Protomaps: an open source map of the world, deployable as a single static file.
2024‑08‑29: Your immune system is not a muscle.
2024‑06‑24: Resolving metastability issues during bootstrapping CLOS.
2021‑07‑06: How Black handles comments when Python's grammar ignores them.
2023‑09‑11: HDMI ISA graphics card for vintage PCs by improving the Graphics Gremlin.
2023‑09‑19: EPDiy: an ESP32-based driver board for e-Paper / E-ink displays.
2024‑06‑20: Avoiding the top 10 NGINX configuration mistakes.
2021‑05‑02: The honest troubleshooting code of conduct.
2021‑09‑15: Single-pass online statistics algorithms.
2024‑10‑23: Adding row polymorphism to Damas-Hindley-Milner.
2024‑08‑27: MiniJinja: learnings from building a template engine in Rust.
2024‑06‑06: Shortcat: Manipulate macOS masterfully, minus the mouse.
2022‑01‑26: Machine readable specifications at scale.
2024‑04‑19: Cable maintenance ships: The invisible seafaring industry that keeps the internet afloat.
2023‑11‑20: Friends don't let friends make bad graphs.
2021‑08‑16: Namespaced De Bruijn indices.
2024‑10‑18: superlinker: a tool for reinterpreting ELF executables and shared libraries.
2024‑05‑05: Byte magazine August 1983: The C Language.
2022‑01‑30: Uninitialized memory: unsafe Rust is too hard.
2021‑10‑18: Serialization-based undo with zstd compression.
2021‑06‑08: Kerckhoffs’s law for security engineers.
2023‑04‑22: Escheresque parquet deformations of an aperiodic monotile.
2024‑05‑19: How often is the wife taller than the husband?
2023‑06‑26: Ideal dimensions for PCB breakaway tabs.
2021‑04‑04: Why daylight saving time has not stopped yet in Europe.
2021‑12‑16: Cranelift progress report: a look back at 2021.
2021‑03‑12: A brief history of network router architecture.
2023‑10‑10: ECC RAM on AMD Ryzen 7000 desktop CPUs.
2021‑07‑05: TCP Fast Open? Not so fast!
2024‑06‑17: The ineffable types of Rust: how to make self-borrows safe.
2021‑12‑23: Spotting fake face masks. (FFP2/N95/KN95)
2022‑10‑24: Buffers on the edge: Python and Rust.
2024‑10‑12: The road to OCIv2 images: what's wrong with tar?
2024‑08‑29: What every computer scientist should know about floating-point arithmetic.
2024‑02‑24: Really large git repositories.
2021‑07‑09: How Intel financialized and lost leadership in semiconductor fabrication.
2023‑01‑30: Coloring for colorblindness.
2021‑07‑04: Electron tube new automatic computer: a homemade valve computer.
2021‑02‑16: "Naming things" is a poor name for naming things.
2024‑09‑09: A low-level look at A-normal form.
2021‑03‑25: Julia 1.6 highlights.
2024‑06‑25: Network protocols, sans I/O.
2022‑09‑04: Reviving the coolest film scanner you've never heard of.
2024‑09‑18: Use IDENTITY columns instead of SERIAL in PostgreSQL.
2022‑09‑06: What’s the smallest variety of CHERI? A 32 bit RISC-V CHERI.
2024‑04‑08: It's time for operating systems to rediscover hardware.
2023‑04‑16: The time Bell Labs brought the Statue of Liberty under its roof (literally).
2021‑03‑26: JET.jl: static type checker with type inference for Julia.
2024‑05‑05: Thinking is bad: implications of human error research for spreadsheet research and practice.
2022‑02‑19: How a Saudi woman's iPhone revealed NSO Group’s hacking.
2024‑05‑19: AOT JS compilation by wevaling the wasms.
2024‑09‑03: Is this Rust trait sealed or not?
2021‑06‑05: Integer log10: make your lookup table do more.
2021‑09‑09: Server traffic shaping on Linux with CAKE.
2024‑08‑04: Git credential: password store integration for git-over-https
2024‑01‑05: Speed up your code: don't pass structs bigger than 16 bytes on AMD64.
2023‑10‑20: ANSI terminal security in 2023 and finding 10 CVEs.
2024‑10‑06: Playing with PostgreSQL and the BOLT linker layout optimizer.
2021‑08‑20: Mutable statics in Rust have scary superpowers! Do not use them!
2021‑10‑23: Raspberry Pi 3 fastboot in less than 2 seconds.
2023‑04‑21: n2: an alternative ninja implemrntation in Rust.
2023‑10‑21: The not-so-glamourous origins of standard railway track gauge.
2023‑03‑30: Mozilla XUL layout is gone from Firefox.
2021‑04‑24: The mystery of AS8003 and legacy US DoD IPv4 address space.
2023‑10‑05: ROCkN: Providing GPS-quality timing accuracy with portable optical atomic clocks.
2023‑01‑18: XLR V3: Guinness world record holder for fastest quadcopter drone.
2024‑05‑28: Wasmi WebAssembly interpreter’s new execution engine.
2023‑11‑03: Avoiding fallback and cold paths.
2024‑06‑25: Re-creating early generative art: Schotter, by Georg Nees.
2024‑09‑21: The lost language extensions of MetaWare's High C compiler.
2024‑06‑15: Exponentially better rotations.
2021‑03‑29: Notes on the Internet Congestion Control Research Group meeting at IETF 110.
2021‑09‑30: Second software release for CHERI-RISC-V and Arm Morello capability architectures.
2024‑08‑26: Poor foundations in geometric algebra.
2021‑09‑14: Emulating AMD approximate arithmetic instructions on Intel.
2021‑04‑03: Ink traps and light traps in font design.
2021‑12‑05: restic: backups done right!
2021‑12‑02: Why movie dialogue has become more difficult to understand.
2021‑03‑07: Why I rewrote my Rust keyboard firmware in Zig: consistency, mastery, and fun.
2024‑03‑10: Kinds are calling conventions.
2022‑02‑19: Destroy all values: designing deinitialization in programming languages.
2021‑10‑21: Making slow Rust code fast.
2022‑07‑29: Stop aggregating away the signal in your data.
2021‑09‑16: Exploring 120 years of timezones.
2024‑07‑09: Is prefix of string in table? A journey into SIMD string processing.
2024‑04‑18: A domino computer.
2023‑08‑02: MIT engineers create an energy-storing supercapacitor from cement and carbon black.
2022‑07‑19: CORE-MATH: open source mathematical functions with correct rounding.
2024‑06‑02: Tiny Tapeout: an educational project to get your designs manufactured on a real chip.
2024‑09‑04: LSP: the good, the bad, and the ugly.
2023‑08‑02: Akin's laws of spacecraft design.
2024‑06‑06: First steps with DHCPv6-PD on OpenBSD.
2024‑03‑31: A kinematically coupled piezo nanometer-resolution microscope focus stage.
2023‑04‑16: Registration desk process engineering at a furry convention.
2021‑09‑01: Moiré no more: using FFT to remove halftone patterns.
2022‑12‑12: The golden age of PL research.
2024‑07‑30: Calculating the cost of a Google Deepmind paper, or, how to burn $10,000,000 on an arXiv preprint.
2022‑10‑06: In-place construction for Rust.
2021‑03‑11: String matching based on compile time perfect hashing in Zig.
2024‑07‑15: Objective tests for aphantasia.
2024‑07‑06: Properly property testing concurrent data structures.
2021‑09‑30: JSON in PostgreSQL: how to use it right.
2021‑06‑22: Async Rust: futures, tasks, wakers; oh my!
2023‑09‑18: Oglaf search index.
2023‑10‑23: Y2038: why Steam started picking a random font.
2021‑07‑16: The development of Chez Scheme.
2022‑03‑02: Using DNAME for reverse DNS of inter-RIR transferred IP address ranges.
2024‑06‑06: Propagating bounds through bitwise operations in abstract interpretation.
2021‑03‑30: In MySQL, never use “utf8”. Use “utf8mb4”.
2024‑05‑26: Statically typed functional programming with Python 3.12.
2024‑09‑19: Digital signatures and how to avoid them.
2021‑04‑21: Exploiting vulnerabilities in Cellebrite UFED and Physical Analyzer from Signal's perspective.
2023‑12‑15: Forcy McForceFace: building a keyboard switch force tester out of an old 3D printer.
2022‑04‑01: Three big myths about Covid Omicron.
2024‑09‑24: A few secure random bytes in PostgreSQL without pgcrypto.
2022‑02‑22: A collection of GPS disciplined oscillator designs.
2024‑08‑27: Should scientific fraud and research misconduct be illegal?
2024‑04‑09: An introduction to jump threading optimizations in gcc.
2024‑09‑29: A p-adic representation of the rational numbers for fast easy arithmetic. (1979)
2024‑04‑19: Raw flux streams and obscure formats: Further work around imaging 5.25-inch floppy disks.
2024‑05‑19: VirusTotal YARA has been rewritten in Rust as YARA-X.
2021‑09‑14: An existential crisis resolved: type inference for first-class existential types.
2022‑09‑28: What is PL research and how is it useful?
2024‑04‑17: Will we have a negative leap second?
2023‑11‑14: Let’s be real about dependencies.
2021‑02‑18: Cybersecurity is like food safety: digital HACCP.
2021‑04‑29: An interview with Linus Torvalds on Linux and Git.
2021‑04‑15: The design of tokio-uring: Linux io_uring support for Rust.
2024‑05‑05: Understanding Stein's paradox in higher-dimensional statistics.
2023‑08‑04: The physics of readable code.
2023‑04‑29: gefs: a good enough filesystem for Plan 9.
2024‑04‑03: Multiple cursors for emacs.
2024‑07‑25: An extensive benchmark of C and C++ hash tables.
2024‑04‑30: iRRAM: exact arithmetic in C++.
2023‑06‑04: BRR: A new line drawing method for the cycle savvy.
2021‑06‑30: Where there’s a grille: the hidden portals to London’s underworld.
2022‑10‑14: Modes considered harmful.
2024‑06‑08: Towards federated key transparency.
2021‑11‑21: Dell XPS13 RAM upgrade.
2023‑08‑23: USB HID usage tables.
2024‑05‑28: The Cephes mathematical library.
2024‑07‑08: On understanding data abstraction, revisited.
2023‑05‑30: Futex-likes on non-Linux systems.
2024‑06‑04: Cloning-based context-sensitive pointer alias analysis using binary decision diagrams in bddbddb.
2024‑09‑16: Ante: A low-level functional language with algebraic effects and safe shared mutability.
2023‑01‑31: Adding comments to your static blog with Mastodon.
2021‑12‑01: This shouldn't have happened: A vulnerability postmortem.
2024‑01‑08: niri: A scrollable-tiling Wayland compositor.
2024‑08‑14: Round in circles and back again: Max Roberts updated London Underground concentric circles and spokes map.
2023‑03‑08: How Discord stores trillions of messages.
2024‑01‑14: QMK and keyboards.
2021‑04‑12: What exactly was the point of [ “x$var” = “xval” ]?
2024‑04‑26: Passkeys: a shattered dream.
2024‑06‑02: Tock: an embedded operating system in Rust.
2024‑08‑29: Compiling JavaScript to Wasm: partial evaluation, weval, and the first Futamura projection.
2024‑08‑11: Rosie pattern language: modern text pattern matching to replace regex.
2021‑03‑01: The hijacking of Perl.com.
2024‑06‑29: POSIX 2024 changes.
2021‑03‑02: A rational design process: how and why to fake it.
2024‑09‑01: CHERIoT: a study in CHERI for RISC-V microcontrollers.
2024‑06‑29: A eulogy for DevOps.
2021‑09‑14: HTTP Cache-Control recommendations.
2022‑10‑15: Announcing Algol 68 Genie 3.0
2024‑05‑12: Breaking DKIM and BIMI in 2024 using the Debian OpenSSL bug CVE-2008-0166.
2024‑03‑09: The SuperC parsing framework.
2023‑11‑21: Lessons from METAFONT.
2022‑11‑22: A jq255 elliptic curve specification, and a retrospective.
2023‑09‑10: Adding Wi-Fi to the Macintosh Portable.
2024‑05‑11: Thread: the wireless tech we can't use or teach.
2021‑06‑01: How to test your code.
2021‑09‑17: Hacking CloudKit: How I accidentally deleted your Apple Shortcuts.
2024‑05‑21: Rust's iterators optimize nicely—and contain a footgun.
2021‑04‑11: Using PyTorch and NumPy? You're making a mistake.
2021‑09‑19: Can you see the Republic of Ireland from England?
2021‑03‑27: Sundial: fault-tolerant clock synchronization for datacenters.
2022‑10‑26: Time is an illusion, Unix time doubly so...
2024‑07‑12: Are you sure you want to use mmap() in your database management system?
2021‑03‑11: Estimating connection pool size with PostgreSQL 14 statistics.
2024‑08‑07: Situated software.
2023‑08‑26: I made a Typewriter out of Drums!
2021‑08‑03: Making reasonable use of computer resources.
2022‑01‑03: On recurrences converging to the wrong limit in finite precision, and some new examples.
2022‑04‑10: Abstraction: not what you think it is.
2021‑04‑26: Let’s build a new service manager for Alpine Linux!
2022‑02‑15: Upgrading an iPod in 2022.
2024‑05‑28: Surveilling the masses with Wi-Fi-based positioning systems.
2021‑07‑13: CMake: the dark arts.
2021‑08‑31: The demise of the once mighty Cambridge and District Co-operative Society.
2022‑03‑30: GPT-3 can run code (ish).
2024‑07‑10: Towards reproducible rebuilds of Debian packages.
2024‑05‑13: Submitting a Linux kernel patch with b4.
2024‑05‑12: Functional semantics in imperative clothing in the Roc programming language.
2024‑01‑02: A CAP tradeoff in Kubernetes.
2021‑03‑12: Finding Mona Lisa in the Game of Life.
2024‑08‑18: The door problem: what does a game designer do?
2021‑07‑08: Compiling Rust is NP-hard: the pattern match exhaustiveness checker as a SAT solver.
2021‑12‑27: What if the Flu isn’t “just the Flu?”
2023‑06‑06: Wiio's laws of human communication
2023‑04‑10: Using RP2040 PIO to drive a poorly-designed display.
2024‑06‑25: Sans I/O when the rubber meets the road.
2021‑04‑28: Internal consistency in streaming systems.
2024‑05‑09: Rust through the ages.
2021‑03‑26: Dynamic memory allocation in constexpr in C++20.
2024‑08‑29: Time-series compression algorithms, explained.
2021‑04‑07: Several ways is which software can be surprisingly slow.
2024‑01‑03: Spatial Shell: a window layout assistant for i3 and sway.
2023‑12‑05: A branchless quicksort partition algorithm.
2022‑11‑05: The longest periods of British Summer Time.
2024‑01‑15: MULTIPLY: the Francis Hookham collection of hand held electronic calculators.
2021‑11‑29: Stack safety for free?
2024‑06‑12: Bamboo can be as invasive as Japanese knotweed.
2021‑06‑26: pydantic: data validation and settings management using Python type annotations.
2022‑10‑02: The first RISC: John Cocke and the IBM 801.
2022‑07‑29: A simplified implementation of TypeScript's type system written in TypeScript's type system.
2022‑03‑21: Lanai (the Myrinet CPU architecture) in LLVM.
2023‑03‑03: Atkinson hyperlegible font.
2021‑03‑09: Debian running on Rust coreutils.
2022‑11‑17: A guide to error handling in Rust.
2024‑08‑24: Geometric search trees.
2024‑08‑23: Ted Dunning on histograms vs quantile sketches.
2021‑03‑16: Correct register allocation in Cranelift by fuzzing with a symbolic checker.
2022‑09‑07: Programming with union, intersection, and negation types.
2021‑10‑23: Can we trust Microsoft with Open Source?
2024‑04‑04: Putting an xz backdoor payload in a valid RSA key.
2022‑11‑23: microblog.pub: A self-hosted, single-user, ActivityPub powered microblog.
2024‑07‑19: NSCopyObject, the griefer that keeps on griefing.
2024‑08‑07: A trilingual inscription at Behistun near Persepolis led to the decipherment of cuneiform.
2022‑08‑30: Packed structs in Zig make bit/flag sets trivial.
2022‑08‑20: Faster zlib/DEFLATE decompression on arm64 and x86.
2024‑05‑31: The greatest clock (and map) ever made.
2021‑06‑06: Ordnance Survey height benchmark locations.
2024‑06‑16: MicroMac, a 128k Macintosh emulated on an RP2040.
2024‑08‑04: Helmut Schmidt Future Prize acceptance speech by Meredith Whittaker.
2021‑09‑15: DART: the Disability Attitude Re-adjustment Tool.
2022‑10‑26: Where else in London are there pylons?
2024‑05‑12: Can we make bicycle manufacturing sustainable again?
2024‑07‑12: Nine rules for successful power meetings.
2023‑07‑17: Appreciating RFC 8927 JSON type definition.
2023‑05‑29: SectorC: A C Compiler in 512 bytes.
2024‑08‑25: Linux pipes are slow.
2022‑04‑25: Low-latency high-throughput garbage collection.
2021‑09‑14: logos: create ridiculously fast lexers in Rust.
2023‑03‑15: No more DSLs: Implement and deploy a distributed system with a single program.
2024‑03‑31: A systematic analysis of the Juniper Dual EC DRBG backdoor.
2023‑04‑22: The magic of DC-DC voltage conversion.
2024‑06‑18: Equality has more than one meaning in mathematics.
2021‑11‑12: Overview of the Rust compiler.
2021‑04‑14: fuzzcheck-rs: Structure-aware, in-process, coverage-guided fuzzing engine for Rust.
2022‑05‑27: Searching 32 million academic papers for obscene acronyms hidden in the titles.
2023‑07‑22: Managing kitchen fruit flies with a Little Shop of Horrors.
2024‑06‑01: X is justifiably slow?
2024‑04‑01: The muscular imagination of Iain M. Banks: a future you might actually want to live in.
2024‑08‑14: The medieval 'New England': a forgotten Anglo-Saxon colony on the north-eastern Black Sea coast.
2021‑12‑18: PostgreSQL is a great pub/sub and job server.
2024‑06‑16: There are only three frequencies: never, sometimes, always.
2021‑07‑11: It’s not always iCache.
2024‑06‑12: Inside Mexico’s anti-avocado militias.
2024‑03‑05: Behind F1's velvet curtain.
2024‑06‑22: The simple essence of algebraic subtyping: principal type inference with subtyping made easy.
2023‑11‑28: It's About Time! Accurate clocks in distributed systems.
2021‑12‑01: An illustrated guide to elliptic curve cryptography validation.
2024‑07‑26: Meta-Thunderbolt-Inception
2021‑12‑02: Tvix: we are rewriting Nix.
2024‑09‑01: A simple generic parallelism idiom and C++17 specifics.
2024‑08‑08: A better light source for scanning color negative film.
2024‑07‑26: Rosemary Grant on the Galapagos finches: “Evolution happens much quicker than Darwin thought”.
2024‑05‑02: PaperWM.spoon: tiled scrollable window manager for Hammerspoon on MacOS.
2021‑02‑25: rpi-open-firmware: Open source VPU side bootloader for Raspberry Pi.
2023‑08‑02: Why Python is terrible.
2021‑04‑06: Debugging random slow writes with GIN indexes in PostgreSQL.
2021‑03‑05: Project Champollion: reverse-engineering Rosetta 2.
2021‑05‑27: Of donkeys, mules, and horses: data structures for network prefixes in Rust.
2022‑05‑07: Shaving is too expensive.
2024‑06‑20: How to use the new counted_by attribute in C and Linux.
2021‑02‑25: An exploration of JSON interoperability vulnerabilities.
2024‑05‑09: The await event horizon in JavaScript.
2024‑05‑30: Why, after 6 years, I’m over GraphQL.
2024‑05‑28: IPv6 link-local stunts: ping ff02::1 etc.
2024‑05‑17: What even is a pidfd anyway?
2022‑09‑04: The as-if infinitely ranged (AIR) integer model.
2021‑03‑28: Pin and suffering in async Rust.
2023‑09‑25: The invisible problem with editing text on phones.
2024‑07‑31: Where does the name "algebraic data type" come from?
2024‑06‑07: Speeding up rustc by being lazy.
2021‑03‑12: Measuring frecency (a combination of frequency and recency) with exponential decay.
2021‑03‑17: Why COBOL isn't the problem.
2022‑04‑11: Pointers Are Complicated III: pointer-integer casts exposed. (strict provenance in Rust)
2024‑03‑06: Conway’s Law: the only unbreakable law.
2021‑06‑22: What is CapTP, and what does it enable?
2024‑07‑12: Beating the cache with value speculation.
2022‑03‑14: RP2040 Doom.
2024‑06‑09: A (draft) taxonomy of SIMD usage.
2022‑11‑26: The EU eIDAS regulation and QWAC x.509 certificates.
2024‑08‑23: We need visual programming. No, not like that.
2024‑06‑04: automemcpy: a framework for automatic generation of fundamental memory operations.
2021‑10‑13: Kathleen Stock, TERF.
2022‑11‑03: Sugar substitutes surprise.
2023‑12‑16: Why aren't we SIEVE-ing? A new cache eviction algorithm.
2024‑06‑04: Why do electronic components have such odd values? Renard numbers and ISO 3.
2024‑06‑19: Demystifying Rust's ? operator and Try trait.
2023‑05‑22: Wrench: an embedded interpreter.
2024‑06‑26: Profiling with ctrl-C.
2021‑06‑05: From Julia to Rust.
2021‑08‑08: Edward Luper’s 36 Views of the BT Tower.
2021‑03‑02: Taking this serially.
2022‑07‑27: Twenty years of Valgrind.
2022‑01‑13: Hate leap seconds? Imagine a negative one!
2023‑10‑20: TLS MITM attack against a Russian XMPP / Jabber service.
2022‑07‑22: Formal CHERI: rigorous engineering and design-time proof of full-scale architecture security properties.
2023‑11‑12: Space Invaders street art mosaics.
2024‑03‑29: A new provisioning tool built with mgmt.
2021‑11‑18: Vulnerabilities show why STARTTLS should be avoided if possible.
2021‑09‑26: A history of library hand.
2022‑11‑14: Canary in the kernel mine: exploiting and defending against same-type object reuse.
2021‑09‑18: The Negro Subversive on Critical Race Theory.
2023‑02‑28: HOTscript: higher-order TypeScript, a library for type-level madness.
2024‑03‑04: Motion blur all the way down.
2023‑08‑31: Ad-hoc polymorphism erodes type-safety.
2021‑10‑25: blamer.el: A git blame plugin for emacs inspired by VS Code's GitLens plugin.
2023‑11‑17: Oops! We Automated Bullshit.
2023‑04‑08: Database “sharding” came from Ultima Online?
2024‑01‑29: Recursive macros with C++20 __VA_OPT__.
2021‑08‑07: The tao of Unicode sparklines.
2022‑05‑29: RFC 3339 vs ISO 8601
2022‑09‑04: I ran the worlds largest DDoS-for-Hire empire and CloudFlare helped.
2024‑07‑12: That afternoon headache is a sign of stale air.
2024‑01‑04: Golang: what we got right, what we got wrong.
2023‑11‑21: How I (kind of) killed Mercurial at Mozilla.
2021‑05‑10: Better performance for dynamic linking with -fno-semantic-interposition.
2021‑10‑02: Clarifying the structure and nature of left-wing authoritarianism.
2024‑03‑30: Basic things to support your software project.
2021‑10‑26: bitbottle: an archive file format (in Rust).
2021‑05‑20: Language compilation speed comparison.
2021‑05‑23: rustc_codegen_gcc can now run libcore’s tests and pass most of them!
2021‑08‑17: Speeding up `atan2f` by 50x.
2021‑03‑05: New Ansible data validation module(s).
2021‑03‑12: Faster inverse BWT.
2024‑07‑11: Hash maps that don’t hate you.
2021‑03‑30: Terrible choices: MySQL.
2021‑02‑24: Git as a tamperproof file archive using chained RFC3161 timestamps.
2021‑03‑04: Do low-level optimizations matter? Faster quicksort with cmov.
2024‑01‑29: __VA_OPT__ minutiae.
2021‑07‑07: Hacker News folk wisdom on visual programming.
2024‑04‑09: The link between abortion and crime.
2021‑09‑03: The scandalous history of the last rotor cipher machine.
2024‑04‑14: Sandboxing all the things with Flatpak and BubbleBox.
2023‑01‑05: Reflecting on transducers in Scheme.
2024‑07‑26: CompilerFax: phone a compiler, fax it some code, it faxes back the results.
2024‑05‑18: TCP performance and the Mathis equation.
2022‑02‑15: A decade of major cache incidents at Twitter.
2022‑04‑26: The problem with mechanical keyboard switch reviews.
2023‑10‑02: The Marvin attack: Bleichenbacher returns, again.
2023‑10‑21: Analyzing data 180,000x faster with Rust.
2022‑06‑04: Remembering Ned Freed (1959-2022).
2021‑04‑25: Parsing protobuf at 2+GB/s: how I learned to love tail calls in C.
2021‑07‑09: A survey of approaches to securing BGP and inter-domain routing.
2023‑10‑05: The Terminal Escapes: Engineering unexpected execution from command line interfaces.
2021‑03‑20: Regexploit: a tool for finding DoS-able regular expressions.
2021‑11‑14: Tests aren’t enough: adding type hints to Python urllib3.
2022‑09‑17: Qiwi: A quick, emulation-focused launcher for QEMU.
2024‑05‑14: A triad of factors that explain the nature of software.
2022‑03‑19: BOOTP and ARP history.
2022‑01‑28: Summary of the USA federal government’s zero-trust memo.
2021‑06‑11: cap: an allocator that can track and limit memory usage in Rust.
2022‑03‑24: DNSSEC algorithms for TLDs (and everyone else).
2024‑08‑10: Confusion attacks: exploiting hidden semantic ambiguity in Apache httpd.
2022‑04‑01: Laura Kuenssberg’s time as BBC Political Editor has been a catastrophic, systemic failure.
2023‑12‑13: Unauthenticated Bluetooth keystroke-injection in Android, Linux, macOS, and iOS.
2021‑10‑11: Benchmarking oksh (OpenBSD Korn shell) with lots of C compilers.
2021‑03‑28: Developer tools can be magic. Instead, they collect dust.
2024‑07‑18: Hash-based bisect debugging in compilers and runtimes.
2022‑07‑07: UDDSketch: a C implementation of DDSketch with a better uniform collapsing strategy.
2024‑07‑21: How not to use box shadows.
2024‑04‑05: The state of time in Rust: leaps and bounds.
2022‑04‑18: Locales, encodings, Unicode, and C++.
2024‑05‑16: Some notes on Rust, mutable aliasing, and formal verification.
2022‑11‑10: BRAVO: biased locking for reader-writer locks.
2024‑07‑11: First contact with SQLite.
2021‑04‑04: A history of IRC (Internet Relay Chat).
2024‑05‑28: Programming pearls: Bumper sticker computer science.
2022‑01‑17: Why Macron’s use of the French swear word ‘emmerder’ is so hard to translate.
2022‑04‑16: Why I avoid async/await in JavaScript.
2024‑04‑24: So you want to learn to break ciphers?
2023‑09‑09: Good performance is not just big O.
2022‑05‑09: Agile and the long crisis of software.
2021‑09‑27: Dealing with the Roman Calendar.
2024‑04‑24: How web bloat impacts users with slow devices.
2023‑11‑14: Replacing HLS/DASH with Media over QUIC.
2023‑04‑26: You could have invented futexes.
2023‑01‑28: C needs a new type qualifier: it’s time for null pointer safety.
2024‑06‑04: bddbddb: using Datalog with binary decision diagrams for program analysis.
2024‑08‑02: Another variable-length integer encoding.
2022‑11‑06: The SAFe delusion.
2024‑08‑03: Primitive recursive functions for the working programmer.
2021‑03‑06: No one is prepared for hagfish slime.
2022‑09‑06: Someone’s been messing with Python’s floating point subnormals!
2024‑03‑25: Interval parsing grammars for file format parsing.
2024‑06‑23: Why is AVX 512 useful for the RPCS3 PlayStation 3 emulator?
2024‑03‑04: The hunt for the missing graph data type.
2021‑06‑15: Celebrating 30 years of Europe’s first root name server.
2024‑07‑15: Pull requests via `git push`.
2023‑07‑29: LPython: novel, fast, retargetable Python compiler.
2024‑05‑18: Fix your video game’s timestep!
2024‑06‑20: Public JavaScript CDNs are useless and dangerous.
2021‑09‑17: TRIPOS historical sources.
2022‑03‑10: A Redis Lua sandbox escape on Debian and its derivatives.
2022‑11‑08: C isn't a programming language anymore.
2021‑04‑06: Wuffs has the fastest, safest PNG decoder in the world.
2023‑07‑16: Penrose: create beautiful diagrams by typing notation in plain text.
2021‑09‑09: Kill It With Fire: dealing with legacy systems. (book review)
2022‑10‑18: Maidenhead locator system map (with small squares).
2024‑06‑01: Electromagnetic linear clock.
2023‑06‑09: Monongahela: a design for a balanced ternary computer.
2021‑08‑09: The rise of Meson.
2024‑05‑26: RuSSH: a Rust SSH client and server library.
2021‑06‑27: systemd, 10 years later: a historical and technical retrospective.
2024‑03‑26: Preventing cross-service UDP loops in QUIC.
2024‑07‑18: Why Polars rewrote its Arrow string data type.
2024‑07‑03: The sad state of property-based testing libraries.
2021‑07‑18: Inserting one billion rows into SQLite in under a minute.
2021‑10‑21: Function pipelines: Building functional programming into PostgreSQL using custom operators.
2024‑07‑19: Concerns about passkeys.
2024‑04‑30: PowerShell monad manifesto.
2023‑05‑07: Mysteries of the Griffin iMate and the Apple Extended Keyboard II.
2023‑09‑02: Spoofing certificates with MD5 collisions in 2022.
2023‑08‑23: ROMRAM: using QSPI RAM with RP2040's SSI in read-write mode.
2023‑10‑03: x86 amd64 SIMD instruction list: SSE to AVX512.
2024‑05‑16: Strings in Julia vs Rust: you probably don't need to validate UTF-8.
2024‑03‑07: CAP twelve years later: how the "rules" have changed.
2024‑05‑16: A look at the Mojo language for bioinformatics.
2024‑07‑27: Counting bytes faster with SIMD, interleaving, and prefetching.
2024‑07‑27: Unsafe read beyond of death: optimized short string SIMD load.
2024‑06‑16: Stupid TLS facts: session resumption.
2024‑06‑24: ChocoPy: a subset of Python 3 for teaching compiler construction.
2021‑11‑21: elfshaker stores binary objects efficiently; designed for manyclangs.
2023‑12‑26: Reptar: an Intel x86 microcode bug.
2021‑08‑14: Emacs development charts, 10×10%.
2021‑07‑01: Hardware memory models.
2024‑05‑15: The creator of Magic: The Gathering knows exactly where it all went wrong.
2024‑05‑01: It's time to stop recommending Clean Code.
2022‑11‑19: GitOpper: GitOps without Kubernetes.
2022‑10‑07: Hard mode Rust.
2022‑01‑09: Will Britain survive?
2024‑05‑21: vu128: Efficient variable-length integers
2024‑05‑28: A study of MAC address randomization in mobile devices and when it fails.
2024‑07‑30: Quint: An executable specification language with delightful tooling based on the temporal logic of actions (TLA).
2021‑12‑03: Don't make my mistakes: common infrastructure errors i've made.
2022‑07‑29: Actually Portable Executables with Rust and Cosmopolitan libc.
2023‑08‑29: Grave flaws in BGP error handling.
2022‑01‑25: World of constellations: a multicultural star map.
2024‑06‑04: LL and LR in context: why parsing tools are hard.
2023‑08‑06: Why does libvirt support only 14 hot-plugged PCIe devices on x86-64?
2021‑12‑16: gRPC best practices.
2021‑03‑10: HTML5 genetic algorithm 2D car thingy.
2023‑09‑11: The Carrington Event of 1859 disrupted telegraph lines. A “Miyake Event” would be far worse.
2021‑09‑14: Ora2PG now supports oracle_fdw to increase data migration speed.
2023‑08‑22: Building and customizing a Kyria wireless ergonomic keyboard.
2024‑02‑07: jj init : an introduction to the jujutsu version control system.
2024‑04‑16: Some useful types for database-using Rust web apps.
2024‑05‑29: Why rejecting invalid XML in the browser is a bad idea.
2021‑03‑04: Don't blindly prefer `emplace_back` to `push_back` in C++.
2023‑09‑29: A plot of all objects in the universe.
2022‑05‑20: Logging C function calls with cosmopolitan libc.
2021‑07‑27: Why neoliberalism needs neofascists.
2024‑05‑05: TypeID: type-safe, K-sortable, globally unique identifiers.
2023‑07‑30: Workarounds for C11 _Generic().
2021‑06‑28: How to evaluate Emacs Lisp in regex search and replace.
2023‑05‑03: I want to talk about WebGPU.
2024‑04‑30: Bytecode VMs in surprising places.
2024‑07‑04: xsum: exactly-rounded summation of floating point values.
2021‑07‑13: Updating the Golang memory model.
2024‑05‑13: Exploring GNU C extensions in the Linux kernel.
2022‑05‑29: Thoughts on FORTH programming.
2024‑05‑19: Compilers for free with weval, a wasm partial evaluator.
2021‑04‑01: Using Rust to corrode insane Python run-times.
2022‑05‑17: DevOps inspiration from Toyota Production System and Lean considered harmful.
2023‑05‑07: The tale of -mrtd in GCC and Clang.
2024‑02‑13: Conway's Game of Life is omniperiodic.
2024‑04‑05: The case against self-closing tags in HTML.
2022‑05‑06: A mystery of unnecessary Rust crate recompilation.
2024‑04‑24: Digitized continuous magnetic recordings of the Carrington event from Greenwich and Kew.
2021‑04‑06: Foreign Data Wrappers for migrating from Oracle to PostgreSQL.
2021‑08‑03: Unix for TOPS-20 users. (1987)
2021‑02‑25: The ternary computing manifesto.
2021‑06‑11: Can memcpy be implemented in LLVM IR?
2023‑10‑03: The 300% production problem.
2022‑09‑08: bstr: A byte string library for Rust.
2022‑05‑25: Modern programming languages require generics.
2022‑08‑02: A new `impl Trait` for Rust.
2022‑11‑03: Comparing TCP and QUIC.
2021‑12‑02: Ideal monitor rotation for programmers .
2024‑07‑13: git-pr: A new git collaboration service.
2021‑02‑18: Power-of-2-choices in practice.
2022‑11‑16: Absorbing commit changes in Mercurial 4.8.
2024‑04‑15: Five little languages and how they grew: Dennis Ritchie’s talk at HOPL on the history of C.
2021‑03‑18: How GitHub found and fixed a rare race condition in session handling.
2021‑08‑11: A little bit about PRNG stuff in Rust.
2022‑01‑01: A brief history of Dell Unix.
2021‑04‑07: Fast and extensible equality saturation with egg and Rust.
2024‑05‑02: Unwind considered harmful?
2021‑12‑05: Securing updates for GNU Guix.
2021‑09‑01: In defense of blub studies.
2022‑02‑15: Journeying into XDP: Fully-fledged DNS service augmentation.
2022‑03‑28: “You build it, you run it” playbook.
2024‑05‑02: Piccolo: a stackless Lua interpreter in Rust.
2024‑06‑22: Optimizing SQLite for servers.
2024‑05‑15: A tale of two sieves.
2021‑09‑30: The Biggest Churches in the World: Anglo-Norman eleventh-century cathedrals.
2022‑11‑23: Takahē: An efficient multi-domain ActivityPub server.
2023‑10‑09: UK postal address oddities.
2022‑02‑23: A cursed RDMA bug.
2022‑09‑29: How to build a personal webpage from scratch.
2022‑09‑27: The web site performance golden rule.
2024‑07‑16: How the Stream Deck rose from the ashes of the legendary Optimus Maximus keyboard.
2021‑11‑18: Support for IPv6 link local addresses in browsers.
2021‑03‑04: HTTPWTF?!
2021‑10‑21: Context-preserving error handling in Rust.
2022‑04‑27: SELinux is unmanageable; just turn it off if it gets in your way.
2024‑05‑26: Taming floating-point sums with Rust.
2022‑08‑29: CSS classes considered harmful.
2022‑09‑12: Ladybird: A new cross-platform browser from the SerenityOS project.
2021‑02‑28: TLD graveyard.
2024‑05‑17: Golang disables Nagle’s algorithm, making it evil on shitty networks.
2021‑06‑27: Why did we ever think the first programming language didn't matter?
2021‑08‑29: Why is the S combinator an S?
2023‑01‑08: User-level implementations of RCU (read copy update).
2023‑05‑23: Unpacking 5 billion varints in only 4 billion CPU cycles.
2021‑09‑02: Netflix audio description style guide.
2024‑04‑27: Tasks are the wrong abstraction for async Rust.
2023‑09‑14: Pagefind and URL search parameters.
2024‑05‑17: A transport protocol's view of Starlink.
2023‑06‑04: Calculating position from raw GPS data.
2024‑03‑11: Staged generic programming.
2021‑05‑02: Hosting SQLite databases on Github Pages (or any static file hoster).
2022‑03‑31: Moderating content supports the principles of free speech.
2023‑08‑13: Virtualizing uxn.
2022‑04‑10: So you want to study mathematics…
2021‑06‑11: Time and date syntax used by systemd.
2023‑05‑12: PS-HTTP: a web server written in PostScript.
2024‑05‑03: ECDH-OMR: elliptic curve Diffie-Hellman oblivious message retrieval.
2024‑06‑06: lelwel: a resilient LL(1) parser generator for Rust.
2021‑12‑18: age-plugin-yubikey: YubiKey plugin for age encryption.
2022‑01‑14: Are you sure you want to use mmap() in your database management system?
2021‑07‑28: Cryptanalysis of Meow Hash.
2021‑09‑15: Freedom of Information as a tool for making cycle routes more accessible.
2023‑04‑30: Basics of space flight: orbital mechanics.
2021‑04‑09: Asahi Linux for Apple M1: progress report, January / February 2021.
2023‑02‑05: Where is the most densely populated square kilometre in the UK?
2021‑10‑26: Comparing open source BGP stacks.
2021‑07‑05: GitHub Copilot is not infringing your copyright.
2022‑12‑26: Verifying concurrent memory reclamation algorithms with grace.
2024‑05‑29: Recycling steel with cement in an arc furnace could produce zero-emissions concrete.
2023‑02‑03: Weird things I learned while writing an x86 emulator.
2024‑06‑13: Whose CIDR is it anyway? Scanning all of whois and rdap.
2021‑02‑28: How I cut GTA Online loading times by 70%.
2022‑05‑07: Xilem: an architecture for UI in Rust.
2021‑03‑07: Don’t use 7-segment displays.
2021‑09‑06: Computational hierarchy of elementary cellular automata.
2024‑05‑16: History of the Italian electrical system.
2022‑04‑10: Beyond bufferbloat: End-to-end congestion control cannot avoid latency spikes.
2021‑02‑19: Reliability, constant work, and a good cup of coffee.
2021‑06‑07: Using a SmartCard HSM for DNSSEC with BIND, Knot DNS, and LDNS/NSD.
2021‑05‑27: An introduction to Jorvik, Ada’s new tasking profile.
2021‑04‑05: TextEdit TXT/HTML type sniffing vulnerability on macOS (CVE-2019-8761).
2021‑07‑04: Ode to a world-saving idea: attribution error and cognitive empathy.
2023‑04‑10: Can you trust a compiler to optimize (even vectorize) your code?
2024‑05‑18: Fixing iterative damping interpolation in video games.
2022‑10‑27: Contention on multi-threaded regex matching in Rust.
2022‑10‑10: The Google plasma globe USB keystroke injection attack.
2021‑06‑03: How malloc broke Serenity's JPGLoader, or: how to win the lottery.
2022‑11‑10: Scalable reader-writer locks.
2024‑06‑02: The borrow checker within Rust.
2021‑04‑16: Actually, you are rolling your own crypto.
2024‑06‑09: Using HDMI EMI for fast wireless data transfer.
2021‑02‑25: Putting DNSSEC signers to the test: Knot vs Bind.
2021‑05‑06: EverParse: Hardening critical attack surfaces with formally proven message parsers.
2024‑05‑19: I am too old to create a popular programming language.
2022‑03‑16: Daylight saving time gripe assistant tool.
2023‑05‑08: On custom-width integer types.
2024‑07‑02: BusyBeaver(5) is now proved to be 47,176,870.
2024‑05‑11: Why the CORDIC algorithm lives rent-free in my head.
2021‑10‑11: MMP at 25: how proportional representation changed New Zealand forever.
2024‑02‑22: A security kernel based on the lambda calculus.
2024‑03‑12: yet-another-cad-viewer: display OCP/CadQuery/Build123d models in a web browser.
2022‑10‑04: Illuminating synchronization edges for ThreadSanitizer.
2021‑10‑21: Social media doesn't turn people into assholes, and everyone's wrong about echo chambers.
2022‑11‑30: The huge Game of Life caterpillar spaceship.
2023‑01‑25: Do not taunt happy fun branch predictor.
2021‑03‑11: Generalizing over generics aka higher kinded types in Rust.
2024‑05‑06: Decoding UTF8 with the pext parallel extract instruction.
2023‑10‑13: Thumb calendar.
2022‑11‑30: Any Game of Life pattern can be constructed from just 15 gliders.
2021‑03‑29: The actual OSI model.
2021‑12‑31: Some sanity for C and C++ development on Windows.
2021‑03‑30: MySQL: do not pass this way again.
2021‑03‑06: Cleaning up your PostgreSQL database.
2024‑06‑17: Zig-style generics are not well-suited for most languages.
2021‑09‑01: Moiré no more: using FFT to remove halftone patterns.
2021‑12‑15: IPv4 address markets.
2021‑06‑11: Behavior inheritance in Rust.
2023‑11‑27: The largest number representable in 64 bits.
2021‑05‑08: The byte order fiasco.
2021‑11‑13: The weirdest QNX bug I've ever encountered.
2024‑06‑21: 1/25-scale Cray C90 wristwatch.
2022‑08‑14: Getting the world record in HATETRIS.
2023‑08‑23: USB HID device class definition.
2021‑08‑21: Tesla Dojo: a custom chip for very high capacity AI training.
2022‑03‑17: C isn't a programming language anymore.
2024‑04‑17: Feathers are one of evolution’s cleverest inventions.
2023‑05‑10: Semantics and scheduling for machine knitting compilers.
2021‑06‑11: Don’t feed the thought leaders.
2023‑12‑30: Git commit signing is kinda wack.
2022‑08‑11: Brimar thermionic products great British valve project.
2023‑06‑24: No vehicles in the park: a game about content moderation.
2024‑04‑26: Captain Zilog crushed! The story of the Z8000.
2023‑05‑01: A mirror for Rust: compile-time reflection.
2021‑02‑22: Stop your (business rules) engines!
2024‑03‑03: 50 years ago: the new Cambridge University Press printing house.
2021‑09‑16: Go to sleep little iPhone: lost broadcasts on WiFi.
2024‑06‑08: Compilers are (too) smart: a failed popcount optimization.
2024‑01‑17: Passing nothing is surprisingly difficult: empty slices in C, C++, and Rust.
2024‑05‑05: How to build a $20 billion semiconductor fab.
2024‑04‑16: Etak Navigator: how they made a mapping computer in the 1980s.
2023‑12‑26: What is a parser mismatch vulnerability?
2022‑04‑20: Changing llvm libc++ std::sort() at Google and beyond.
2022‑01‑13: Async Rust in ScyllaDB: performance, pitfalls, profiling.
2024‑04‑01: When concurrency matters: behaviour-oriented concurrency.
2024‑05‑16: Ebury is alive but unseen: 400k Linux servers compromised by the Windigo group.
2021‑03‑07: Fast file copy with io_uring.
2022‑08‑04: The original social network: other people’s websites.
2024‑06‑07: Leveraging Zig's allocators.
2021‑04‑17: Lars Wirzenius would like to review your README.
2021‑10‑13: The problem with function namespaces and Lisp macros.
2022‑09‑18: GCC's new fortification level: The gains and costs.
2023‑08‑31: The mystery of the Bloomfield bridge.
2024‑06‑06: let rand = main as usize;
2024‑05‑14: Optimizing the Roc parser/compiler with data-oriented design.
2023‑03‑10: \Device\Afd: what makes async Rust and libuv work on Windows.
2023‑10‑20: How to mitigate the Hetzner/Linode XMPP.ru MitM attack.
2021‑03‑16: The prevalence, persistence, and perils of lame delegations.
2024‑06‑18: Avoiding Emacs bankruptcy.
2021‑03‑16: The origins and motivations of univalent foundations: computer proof verification to avoid mathematical mistakes.
2024‑05‑16: Understanding misunderstandings in C source code using IOCCC winners.
2021‑08‑14: A probabilistic solution to the three-body problem.
2022‑01‑14: Nominative determinism in hospital medicine.
2021‑02‑13: SVG: the good, the bad, and the ugly.
2022‑12‑20: How to draw ugly lines really fast.
2021‑09‑19: How does Ouroboros relate to RINA, the Recursive InterNetwork Architecture?
2021‑03‑08: yacv (Yet Another Compiler Visualizer): LL and LR parser animations.
2023‑05‑17: Logs said it was DNS, it looked like DNS, it had to be DNS, it wasn't DNS.
2023‑09‑21: Speeding up the JavaScript ecosystem: polyfills gone rogue.
2021‑03‑01: Eight million pixels and counting: improving texture atlas allocation in Firefox WebRender.
2023‑10‑19: Stop your (business rules) engines!
2022‑10‑07: On the DeepMind AlphaTensor new matrix multiplication algorithms.
2022‑09‑30: The thorny problem of keeping the Internet’s time.
2023‑09‑12: What’s the smallest variety of CHERI?
2023‑04‑10: Night of the living brain fog, or how I hacked my sleep apnea better thanks to open source software.
2021‑09‑05: Notes from a 1984 trip to Xerox PARC.
2022‑05‑07: Identity crisis: sequence vs UUID as primary key.
2021‑08‑29: Four months with Ada.
2024‑06‑07: What is PID 0?
2021‑08‑20: Monks Wood Wilderness: 60 years ago, scientists let a farm field rewild; here's what happened.
2022‑12‑08: Goodbye to the C++ implementation of Zig.
2023‑11‑29: Destructing trees safely and cheaply.
2023‑12‑04: You don't need JavaScript for that.
2024‑05‑06: The C++ iceberg.
2022‑12‑04: Building a virtual machine inside ChatGPT.
2022‑05‑12: Fuzzing an eBPF implementation in Rust.
2024‑02‑14: Thomas Rokicki’s survey of algorithms for Conway’s Game of Life.
2023‑04‑10: nsss: a secure NSS-like implementation for static linking.
2024‑03‑09: Call-by-push-value. (1999)
2024‑03‑28: Binary Fuse Filters: fast and smaller than xor filters.
2021‑02‑19: Cleaner parallel curves with Euler spirals.
2021‑05‑28: A year in the Nakagin tower’s metabolist future of 1972.
2021‑07‑09: mull: Practical mutation testing for C and C++.
2024‑04‑28: Building an IBM 3270 terminal controller.
2022‑10‑14: Make your QEMU 9p server 10 times faster with this one weird trick.
2021‑08‑20: Patterns in confusing explanations.
2023‑03‑07: How UC Davis medical school became remarkably diverse.
2024‑06‑04: Simple proofs with Z3Py.
2022‑04‑18: Exponentially better rotations.
2024‑03‑03: The case against geometric algebra.
2024‑03‑09: I'm betting on call-by-push-value.
2022‑04‑04: Horrible edge cases to consider when cataloguing music.
2021‑05‑31: PostGIS at 20: the beginning.
2021‑04‑01: How does Golang know time.Now?
2024‑05‑28: I’ve womansplained him to death.
2023‑07‑21: HP-1973: an HP calculator emulator.
2021‑03‑11: inet.af/netaddr.IP: a new IP address type for Golang.
2021‑06‑02: Practical Reed-Solomon for programmers.
2021‑07‑03: wasm2ps: compile a small subset of WebAssembly to PostScript. (using wasm2wat)
2022‑02‑19: Building an intelligent Emacs.
2021‑02‑20: The modern packager’s security nightmare.
2023‑01‑01: Better binary search in Haskell.
2022‑01‑18: GPS.
2024‑06‑07: Tom7’s BoVeX typesetter with AI-assisted justified text.
2021‑03‑11: Safe flexible aliasing with deferred borrows in Rust.
2023‑09‑13: George Gorton Machine Co engraver typefaces.
2024‑03‑19: The invention of fuzz testing.
2021‑03‑02: typescript-is: generate run-time type-checks.
2024‑04‑30: PostgreSQL supported platforms over time.
2021‑03‑18: Country centered map projections.
2021‑12‑01: libtree: ldd as a tree saying why a library is found or not.
2021‑04‑07: Protecting PostgreSQL from FreeBSD's OOM killer.
2021‑04‑01: Speeding up crash recovery and VACUUM in PostgreSQL 14.
2021‑03‑05: Waiting for PostgreSQL 14: SEARCH and CYCLE clauses.
2022‑08‑15: Retroﬁtted parallelism considered grossly sub-optimal.
2024‑04‑03: Diff modulo base, for comparing rebased branches.
2023‑11‑05: A proposed fix for C/C++ relaxed atomics in practice.
2023‑05‑29: ITU News Magazine: The future of Coordinated Universal Time.
2022‑11‑14: Rust and C++ interoperability.
2023‑11‑15: Popcount walks: next, previous, toward and nearest.
2024‑05‑05: The Italian streets that don't exist on any map.
2024‑02‑26: What is the "God Mode" folder in Windows 10, and how do I enable it?
2024‑03‑04: Migrating from Emacs lsp-mode to Eglot.
2024‑04‑23: No one buys books.
2022‑02‑06: lon lat or lat lon?
2021‑08‑15: Classical data structures that can outperform learned indexes.
2024‑04‑19: A history of parsers of the Ruby programming language.
2024‑03‑09: Call-by-push-value: decomposing call-by-value and call-by-name.
2023‑11‑16: Can your static type system handle linear algebra?
2021‑05‑14: Benchmarking division and libdivide on Apple M1 and Intel AVX512.
2024‑06‑04: Bit-twiddling abstract addition with unknown bits.
2024‑05‑09: It's always TCP_NODELAY. Every damn time.
2023‑08‑07: Reverse Z in 3D graphics (and why it’s so awesome).
2023‑05‑28: Bcrypt at 25: a retrospective on password security.
2024‑05‑28: Doing is normally distributed, learning is log-normal.
2023‑11‑29: Why is Rust slower to read a file than Python?
2024‑01‑04: An overview of the Starlark programming language.
2021‑03‑29: Flicker-free Elite on the BBC Micro (like the BBC Master).
2023‑05‑07: Prolly trees: Merklizing the key/value store for fun and profit.
2024‑05‑13: Parsing JSON is a minefield.
2024‑05‑28: Why software projects take longer than you think: a statistical model.
2022‑11‑18: Will we have a negative leap second?
2021‑03‑06: Web browser architecture and the history of window systems.
2023‑08‑21: Designing a PCB for the RP2040 Microcontroller | Microcontroller Tutorials
2021‑08‑23: One does not simply calculate the absolute value.
2021‑08‑11: Why is tech illustration stuck on repeat?
2021‑06‑03: Design issues in LLVM IR.
2021‑06‑18: Eliminating data races in Firefox with Thread Sanitizer.
2022‑11‑10: Cloning the Linux kernel in under a minute with gitoxide.
2022‑06‑19: Advancing the state of the art for C++ std::unordered_map implementations.
2024‑05‑12: Emoji history: the missing years.
2022‑11‑23: If multicast is the answer, what was the question?
2024‑04‑01: The Wi-Fi only works when it's raining?!
2024‑05‑11: In Rust, methods should be object safe.
2024‑04‑17: The hardest problem in web design: centering things.
2023‑10‑05: Report ITU-R TF.2511-0 (10/2022): Content and structure of time signals to be disseminated by radiocommunication systems and various aspects of current and potential future reference time scales, including their impacts and applications in radiocommunication.
2021‑11‑18: Understanding HKDF.
2023‑07‑11: salty: Ed25519 for ARM microcontrollers.
2021‑09‑15: Taking legal action on inaccessible cycleway barriers.
2024‑03‑31: Countering trusting trust.
2022‑05‑22: Happy 10th birthday to Godbolt’s Compiler Explorer!
2021‑02‑25: Common Nginx misconfigurations that leave your web server open to attack.
2023‑03‑08: The linguistic registers of Rust.
2022‑03‑12: The life of an optimization barrier in Rust and Wasm.
2021‑09‑21: HIBA: Host Identity Based Authorization for SSH.
2021‑10‑03: OpenHaystack: tracking your Bluetooth devices with Apple's "Find My" network
2024‑05‑05: An extended subtweet on power-over, vs power-with or power-to.
2021‑05‑04: Fully automated bootstrapping from source.
2024‑05‑16: D3 in depth.
2022‑03‑12: Marginalia web search engine.
2024‑04‑28: The invention of the integrated circuit recorded in Jean Hoerni's patent notebook.
2023‑10‑19: The road to hell is paved with good intentions and C++ modules.
2023‑05‑13: Building a baseline JIT for Lua automatically.
2022‑01‑13: Ghost in the ethernet optic.
2023‑11‑07: Jezebel and the question of women’s anger.
2021‑07‑21: Keyboard rollover and lockout.
2023‑11‑13: 37 is the median value for the second prime factor of an integer.
2022‑04‑10: Rust's unsafe pointer types need an overhaul.
2021‑08‑03: Choosing properties for property-based testing.
2022‑02‑03: Optimizing GoAWK with a bytecode compiler and virtual machine.
2021‑07‑10: Against SQL.
2024‑04‑09: Halbach magnetic array.
2024‑01‑03: newm-atha: a touchpad and touchscreen centric wayland compositor.
2021‑12‑23: fq: jq for binary formats.
2022‑07‑28: execline: a small scripting language.
2022‑02‑03: Yes, I can query a SQLite database in CSS.
2022‑01‑28: Lights at sea: a map of lighthouses.
2021‑10‑03: R, OpenMP, MKL, disaster.
2021‑07‑03: Phase-in codes.
2021‑03‑19: Fontemon: the world’s first video game in a font!
2023‑09‑29: Who really invented the alphabet?
2022‑09‑26: Zen4's AVX512 teardown.
2024‑04‑05: Features I wish PostgreSQL had as a developer.
2022‑01‑09: Matthew Somerville’s Inky dashboard.
2023‑09‑09: Black-box concurrent data structures for NUMA architectures.
2022‑11‑19: C23 implications for C libraries.
2021‑08‑26: Flexible microprocessor could enable an 'internet of everything'.
2021‑02‑18: Route 53 DNS: Amazon’s premier AWS database.
2022‑11‑14: psyche-c: automatic compilation of partially-available sources.
2021‑03‑15: Performance comparison: counting words in Python, Go, C++, C, AWK, Forth, and Rust.
2021‑10‑18: What every software engineer should know about search.
2024‑04‑30: Rink: an open source unit-aware calculator.
2024‑01‑08: How to stop Linux threads cleanly.
2023‑08‑21: Normal incidents.
2021‑12‑18: untwister: a PRNG seed recovery tool.
2023‑11‑22: Why does the moon change size when you snipe it in GTA?
2021‑07‑07: rustviz: interactive visualization of ownership and borrowing.
2021‑10‑20: I couldn’t debug the code because of my name: unicode pathname bugs in JetBrains IDEs.
2024‑04‑30: State of the terminal.
2021‑02‑14: Holotypic Occlupanid Research Group.
2024‑05‑08: B612: the Airbus cockpit display font.
2024‑03‑28: TCP is an underspecified two-node consensus algorithm and what that means for your proxies.
2023‑11‑20: A close encounter with false sharing in Rust.
2022‑07‑19: Gaussian blue noise.
2023‑11‑23: Wasmtime and Cranelift in 2023.
2022‑02‑19: Jujutsu: A Git-compatible DVCS that is both simple and powerful.
2021‑12‑17: A brutally effective hash function in Rust.
2021‑03‑26: Speculating the entire x86-64 instruction set in seconds with this one weird trick.
2022‑09‑28: Linux kernel __is_constexpr macro.
2024‑05‑05: Bit-stealing made legal: compilation for custom memory representations of algebraic data types.
2023‑11‑16: A subtle Python SIGPIPE bug.
2021‑03‑25: Counting cycles and instructions on the Apple M1 processor.
2022‑11‑21: Is wine fake?
2021‑06‑29: Reinventing the automobile: the first skateboard platform for electric vehicles.
2022‑02‑19: Mergers ruin everything.
2022‑04‑29: Pražský Orloj: Prague astronomical clock simulator.
2022‑02‑26: Curious lack of sprintf scaling.
2024‑04‑10: BatBadBut: You can't securely execute commands on Windows.
2023‑05‑07: On numbering hegemonies and namespace monopolies.
2024‑02‑03: Pkl: a programming language for configuration.
2022‑06‑20: A closer look at CVSS scores.
2021‑10‑23: Coding for non-programmers: we need better web GUI automation tools.
2024‑04‑11: A simple derivation of sin and cos by stacking triangles.
2021‑08‑09: How BCPL evolved from CPL.
2021‑03‑28: Implicit In-order Forests: Zooming a billion trace events at 60fps.
2023‑10‑15: Faster compile times from simpler dependency graphs in Rust.
2021‑04‑06: Ghosts of OSI: the spectre haunting the Internet.
2021‑03‑18: Memory saturated MySQL.
2021‑06‑13: How to handle secrets on the command line.
2021‑11‑24: IDEs and macros and Rust.
2021‑05‑02: Query engines: push vs. pull.
2021‑06‑20: What do you call a Rust pointer we stole the high bits off? An ointer.
2024‑02‑06: RCL: A reasonable configuration language.
2021‑05‑27: Reciprocals in Rust: baseline implementations should be predictable.
2024‑02‑25: Beware of -ffast-math and -Ofast.
2024‑04‑29: The space bar stabilizer problem.
2021‑12‑28: Software Tools in C++.
2024‑04‑25: The weird world of Windows file paths.
2023‑03‑09: The Quest for Netflix on Asahi Linux.
2023‑10‑13: Conical Slicing: A different angle of 3D printing.
2021‑03‑26: A look back at asynchronous Rust.
2023‑07‑31: The Fibonacci matrix.
2021‑06‑04: Anatomy of a Linux DNS lookup.
2021‑03‑18: Writing a PostgreSQL formatter / pretty printer in Rust.
2022‑01‑16: Covid-19 will never become endemic.
2021‑03‑11: A history of CLU.
2021‑10‑04: CBMC: C bounded model checker.
2021‑05‑05: Linear Clock: Solar.
2022‑08‑31: Commodore 64 Theremin.
2021‑03‑06: Generating ePub from LaTeX.
2021‑09‑14: A tale of making a company-wide psqlrc to use with pgbouncer.
2021‑11‑13: It's now possible to sign arbitrary data with your SSH keys.
2022‑03‑30: The British Empire was much worse than you realize.
2022‑12‑06: Is Moore’s Law really dead?
2022‑01‑18: arXiv.org reaches a milestone and a reckoning.
2023‑04‑09: Modular errors in Rust.
2024‑04‑29: So, you want to write an unsafe crate in Rust?
2021‑05‑02: Handling time when programming.
2021‑04‑01: avo: Generate x86 assembly with Golang.
2023‑07‑19: Local async executors should be the default in Rust.
2024‑04‑09: path.join considered harmful, or openat() all the things.
2022‑07‑31: Linux kernel lock engineering principles.
2023‑05‑19: bilge: a bit fiddling proc macro for Rust.
2021‑12‑28: Why Pascal is Not My Favorite Programming Language. (troff source)
2024‑03‑15: JESK56: a diodeless keyboard matrix derived using graph theory.
2021‑10‑21: Did the Big Bang begin from a singularity? Not anymore.
2023‑08‑31: Co-dfns versus BQN's implementation.
2024‑03‑21: Progressing towards the redefinition of the second based on an optical frequency standard.
2023‑10‑10: Text showdown: gap buffers vs ropes.
2021‑03‑23: Automatic video editing for presentations.
2022‑11‑09: What is PostgreSQL commitfest?
2022‑11‑23: Building the fastest Lua interpreter.. automatically!
2021‑06‑21: Expanding TeX's \newif.
2022‑04‑10: The struggle of using native emoji on the web.
2021‑08‑07: A USB adapter for a Depraz mouse.
2021‑12‑26: State of Valhalla, part 1: value types for the JVM.
2022‑09‑09: Parallel curves of cubic Béziers.
2021‑05‑03: Dissecting the Apple M1 GPU, part IV.
2021‑08‑25: Hiding images in plain sight: an acrylic magic window that can project a picture.
2021‑03‑19: MOnSter 6502
2022‑04‑18: It's always DNS . . . except when it's not: A deep dive through gRPC, Kubernetes, and AWS networking.
2022‑04‑01: DDC OLED: how to drive a tiny display from an HDMI port.
2021‑10‑26: austral: a systems language with linear types.
2022‑12‑21: Deriving a bit-twiddling hack: signed integer overflow.
2023‑11‑07: Can solar and wind power Britain? An update of David MacKay’s numbers.
2023‑01‑08: The DIY scientist, the olympian, and the mutated gene.
2021‑03‑19: Consistent overhead byte stuffing for binary logs.
2023‑12‑21: How to find secure hash collisions.
2021‑04‑04: paged.js: beautiful PDFs from HTML.
2023‑11‑12: A quick look at register allocation with destination-driven code generation.
2021‑07‑08: Dumping and extracting the SpaceX Starlink user terminal firmware.
2021‑03‑07: Memory-mapped IO registers in Zig.
2021‑06‑29: Temporal: getting started with JavaScript’s new date time API.
2022‑04‑10: Authenticated bootstrapping of DNSSEC delegations.
2022‑09‑18: Finding a second bug in glibc’s condition variable with TLA+.
2021‑02‑28: Where everything went wrong: error handling in Rust.
2024‑04‑04: HTTP/2 CONTINUATION flood denial of service vulnerability.
2021‑08‑26: Inko: Friendship ended with the garbage collector.
2021‑11‑04: An oral history of Bank Python.
2021‑03‑17: frawk: an efficient awk-like programming language.
2021‑12‑05: Rclone syncs your files to cloud storage.
2021‑12‑05: Tips on adding JSON output to your command line utility.
2022‑07‑22: Why the NRO is defending AFRINIC.
2023‑09‑19: Making Gaussian Splats smaller.
2021‑09‑14: OLAP != OLAP Cube.
2023‑01‑27: Reverse engineering the original Lytro lightfield camera.
2021‑06‑29: British flag protocol: flying the union jack.
2021‑02‑24: Fuzzy string matching in PostgreSQL.
2022‑10‑04: C++ chrono-compatible low-level date algorithms.
2023‑11‑17: Why you need a "WTF notebook".
2023‑03‑14: Generating aerial imagery with your iPhone’s LiDAR sensor.
2022‑01‑13: PCIe 6 overview.
2023‑09‑01: A deep dive into Single Pair Ethernet.
2023‑11‑21: Drawing diagrams for TeX with MetaPost.
2022‑09‑18: Geometric algebra: what is the inverse of a vector?
2021‑09‑21: A giant space rock demolished an ancient Middle Eastern city and everyone in it, possibly inspiring the Biblical story of Sodom.
2021‑06‑04: Firefox Proton UI userChrome.css fixes.
2022‑11‑21: Why the OpenSSL punycode vulnerability was not detected by fuzz testing.
2021‑10‑21: Stupid tricks with io_uring: a server that does zero syscalls per request.
2021‑11‑21: DwarFS: A fast high compression read-only file system.
2022‑01‑18: Dun, Dun Duuun! Where did pop culture’s most dramatic sound come from?
2022‑04‑21: Coherence and crate-level where-clauses in Rust.
2023‑09‑24: Introducing geometric algebra to software developers: a computational thinking approach.
2022‑08‑28: Weird monitor bugs people sent me in the last 5 years.
2022‑01‑09: How to check you're in the initial pid namespace?
2021‑08‑30: Most information about disinformation is misinformation.
2023‑09‑12: Hacking the Book8088 for better accuracy.
2021‑07‑11: Inline in Rust.
2023‑11‑24: FullControl: unconstrained gcode design for 3D printers.
2021‑09‑30: Rust for the polyglot programmer.
2021‑11‑11: Speed of Rust vs C.
2021‑07‑30: B-tree path hints.
2024‑04‑09: The server chose violence: error handling in the Hubris embedded OS.
2021‑04‑15: Rust shenanigans: return type polymorphism.
2021‑10‑06: How ISO C became unusable for operating system development.
2022‑08‑03: How I do (and don’t) prepare a talk for a tech conference.
2021‑07‑31: strcpy: a niche function you don't need.
2021‑05‑25: RefinedC: automating the foundational verification of C code with refined ownership types.
2021‑09‑12: Okhsv and Okhsl: two new color spaces for color picking.
2022‑10‑01: 9 puzzles to convince you you don't understand dependence.
2023‑12‑10: Lambda to SKI, semantically.
2023‑12‑26: Lotus 1-2-3 for Linux.
2021‑10‑18: The undocumented Microsoft "Rich" PECOFF header.
2022‑08‑07: Computing Adler32 checksums at 41 GB/s.
2021‑08‑18: Exploring Clang/LLVM optimization on a programming horror.
2022‑11‑20: From culinary dud to stud: how Dutch plant breeders built a brussels sprouts boom.
2022‑01‑27: Magic-trace: Diagnosing tricky performance issues easily with Intel Processor Trace.
2024‑03‑12: Identifying software: supply chain security with GNU Guix.
2021‑08‑24: Life before Unicode in Russia.
2021‑09‑04: A nasty bit of implicit timezone behavior in Golang.
2021‑10‑23: A cool Rust optimization story.
2023‑12‑08: A brief history of keyboard encoding.
2021‑02‑23: mold: a modern linker, faster than cat.
2023‑07‑31: What John von Neumann really did at Los Alamos.
2021‑09‑14: Type-checked keypaths in Rust.
2022‑01‑29: An update on rust/coreutils.
2023‑01‑27: Netheads vs. bellheads redux: the strange victory of SIP over the telephone network.
2022‑10‑08: Slides from a lecture series on algebraic geometry for computer graphics.
2021‑04‑04: Why Julia is turning heads in 2021.
2021‑04‑26: Plan 9 history in git, from 1992-09-21 to 2015-01-10.
2024‑03‑13: Mu-Ency: the encyclopedia of the Mandelbrot set.
2023‑10‑03: Arm64 SIMD instruction list: SVE instructions.
2024‑01‑06: Vectrex reborn: How a chance encounter gave new life to a dead console.
2022‑01‑27: Stop brainstorming.
2021‑06‑16: Introducing cap-std, a capability-based version of the Rust standard library.
2021‑07‑30: One tenth of a second.
2023‑05‑11: Building the Micro Mirror free software CDN.
2021‑08‑26: PragmatIC Semiconductor made a flexible 6502 in two weeks.
2023‑05‑11: Building an anycast secondary DNS service.
2022‑12‑26: NBR: neutralization based reclamation.
2021‑08‑06: HTTP/2 desync attacks.
2022‑11‑23: Takahē: An efficient multi-domain ActivityPub server.
2022‑08‑23: VS Code: What's the deal with the telemetry?
2021‑11‑01: C++ coroutines do not spark joy.
2022‑03‑04: Dennis Meadows on the 50th anniversary of the publication of The Limits to Growth.
2023‑01‑01: How to get Xfinity Stream to work on Linux: a tale of Widevine, Chrome OS, and a patched glibc.
2022‑06‑14: STxP70 / STHORM / P2012: ST's secret microcontroller.
2023‑03‑08: Historical notes on computer word and byte sizes.
2024‑03‑30: The "not rocket science" rule of continuous integration (and the story of monotone and bors).
2022‑01‑01: Susie Dent's guide to swearing.
2021‑08‑28: jsc: JavaScript on the macOS command line.
2021‑03‑16: It’s time to stop using SMS for anything.
2021‑04‑19: Dissecting the Apple M1 GPU, part III.
2022‑05‑30: How read-intensive is Linux's use of RCU? (And what is its latency?)
2023‑12‑11: Cutting out continuations.
2024‑03‑10: Do Be Do Be Do, or, Frank: a strict functional programming language with algebraic effects.
2021‑06‑04: Firefox 89 tab appearance fixes with userchrome.css.
2022‑02‑17: PX-1000Cr: Deliberate weakening of a cryptographic algorithm by the NSA.
2022‑01‑25: The truth about inflation.
2022‑10‑01: Adversarial collaboration.
2023‑11‑23: Commercial flights driven off course by GPS spoofing attacks.