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‑04‑23: Detecting if an expression is constant in C.
2025‑02‑26: The miserable state of cellular modems and mobile network operators.
2025‑05‑13: YamlScriot: YAML done wisely.
2025‑03‑30: Hacker laws, theories, principles, and patterns that developers will find useful.
2022‑05‑25: How I think about C99 strict aliasing rules.
2025‑02‑10: Dazed and Confused: a large-scale real-world user study of reCAPTCHAv2.
2023‑03‑07: HVM: higher-order virtual machine, a massively parallel, optimal functional runtime in Rust.
2024‑09‑07: gRPC: the ugly parts.
2025‑04‑25: setenv() isn't threadsafe and even safe Rust didn't save us.
2021‑03‑12: Factoring in gravitomagnetism could do away with dark matter.
2024‑06‑03: {fmt}: a modern C++ string formatting library.
2025‑05‑07: The state of SSL/TLS stacks.
2025‑05‑01: verb: Emacs org mode HTTP client.
2025‑05‑02: Adaptive hashing in SBCL.
2025‑05‑10: Stacking lookup tables in a lexer generator.
2025‑04‑15: The .su ccTLD might be safe after all.
2025‑04‑18: Marching Events: What does iCalendar have to do with ray marching?
2024‑10‑30: Lessons learned from a successful Rust rewrite.
2021‑12‑05: Why is it hard to automatically suggest what index to create?
2024‑10‑27: A comparison of the C# and Rust borrow checkers.
2025‑03‑04: Eradicating trivial vulnerabilities, at scale.
2025‑02‑11: The `satisfies` operator in TypeScript.
2025‑03‑13: When is "this trait can be implemented" part of the trait's public API? Sealed traits in Rust with cargo-semver-checks.
2025‑03‑29: Compiler construction textbook by Niklaus Wirth.
2022‑10‑05: Memories: Edinburgh ML to Standard ML.
2025‑04‑30: BBC 1 logo 1985: a computer originated world.
2025‑03‑16: Performance of Git's new bundle-uri.
2025‑04‑26: Parallel ./configure
2025‑04‑10: Practical UNIX manuals with mdoc: structure, style, and composition.
2025‑05‑10: Beating the fastest lexer generator in Rust.
2025‑05‑06: Propositions as types.
2024‑11‑10: Ferranti punched tape codes, including Flexowriter. (1961)
2025‑01‑09: Rethinking errors, warnings, and lints.
2024‑09‑11: A short guide to the copyright wars.
2024‑08‑14: The soul of maintaining a new machine: communities of practice among Xerox photocopier repair engineers.
2025‑04‑16: Learning rate: What does it mean for a technology (such as solar power) to follow Wright’s Law?
2023‑12‑03: fastgron: make JSON greppable, super fast!
2025‑04‑15: Sunlight: a certificate transparency implementation built for scalability, ease of operation, and reduced cost.
2025‑04‑04: On JavaScript's weirdness.
2025‑04‑14: Flat origami is Turing complete.
2025‑03‑06: The Combined Cipher Machine, 1942-1962.
2023‑08‑20: VIK: an FPC interface for connecting keyboard modules.
2025‑03‑23: browse-at-remote: browse remote code forges with emacs.
2025‑04‑07: A rough survey of compilation, recompilation, and compile-time evaluation.
2024‑08‑21: Which social media sites support which meta tags?
2024‑07‑04: Sans-IO: The secret to effective Rust for network services.
2024‑03‑31: Changes to `u128`/`i128` layout in Rust.
2021‑04‑06: Directory entry says what? Current Gopher type field types.
2025‑05‑02: Designing type inference for high quality type errors.
2021‑10‑16: Hunting down a C memory leak in a Go program.
2024‑11‑04: IAU standards of fundamental astronomy.
2025‑01‑23: Why PostgreSQL major version upgrades are hard.
2023‑01‑08: djot: a light markup syntax.
2025‑05‑02: The one ring problem: abstraction and our quest for power.
2024‑12‑26: SpiNNaker: a million-core ARM machine. (2011)
2025‑04‑27: Technical debt as theory building and practice.
2024‑10‑09: 50 years of database queries.
2024‑06‑29: ChatGPT is bullshit.
2024‑05‑19: polyfill-glibc: patch Linux executables for compatibility with older glibc.
2025‑05‑04: Pixels in Islamic art: square Kufic calligraphy.
2024‑06‑04: You will regret using natural keys.
2025‑04‑15: Fun with -fsanitize=undefined and Picolibc.
2021‑10‑16: Stored procedure OUT parameters in PostgreSQL 14.
2025‑01‑03: Can PostgreSQL use this index, please?
2023‑08‑31: Co-dfns: High-performance, reliable, and parallel APL.
2025‑04‑23: Danglepoise raise/lower dining table lights.
2025‑02‑06: Three basic rules of safety hygiene in Rust.
2024‑07‑04: Beating NumPy's matrix multiplication in 150 lines of C.
2024‑10‑28: Don’t implement unification by recursion.
2025‑04‑08: Obituary for Doug Lenat’s Cyc, the greatest monument to logical AGI.
2025‑04‑10: A discipline of error handling.
2024‑04‑10: A memory of the nineteen-nineties, by Teller.
2024‑11‑01: Control characters in ASCII and Unicode.
2024‑10‑24: A free, open source IPv6 textbook.
2025‑03‑31: WALI: WebAssembly with thin Linux kernel interfaces.
2025‑02‑28: The Fibrovisor: a display made from a tat shop fibre-optic wand.
2024‑12‑23: A worked example of copy-and-patch compilation.
2022‑07‑30: Welcome to the anthropocene: the age of human die-offs.
2025‑04‑25: The Bayeux Tapestry with knobs on: what do its 93 penises tell us?
2025‑03‑24: CSS animation with offset-path.
2024‑09‑05: Why eager languages don't have products and lazy languages don't have sums.
2024‑08‑17: Replace Docker Compose with systemd, podman, and quadlet.
2024‑11‑02: Breaking CityHash64, MurmurHash2/3, wyhash, and more...
2022‑05‑01: Uncurled: everything Daniel Sternberg learned about running and maintaining Open Source projects for three decades.
2025‑04‑18: Exacerbating cross-site scripting: the iframe sandwich.
2025‑03‑27: The Verilog preprocessor: force for `good and `evil
2024‑12‑29: SEninja: symbolic execution plugin for Binary Ninja.
2021‑09‑08: Rust programs written entirely in Rust, without libc.
2021‑09‑30: Always-on processor magic: how “Find My” works while iPhone is powered off.
2025‑02‑16: CPL elementary programming manual.
2022‑01‑08: Dr Russell Barkley’s 30 essential ideas everybody needs to know about ADHD. (YouTube)
2024‑12‑12: Century-scale storage: If you had to store something for 100 years, how would you do it?
2025‑04‑23: Does using Rust really make DNS name decompression safer?
2023‑10‑03: ARMv8 instruction set overview.
2023‑01‑29: Stonebraker: one size fits none: everything you learned in your DBMS class is wrong. (video)
2025‑04‑17: The halting problem is a terrible example of NP-harder.
2025‑04‑17: An iOS dlsym() PAC calculation bug.
2025‑04‑19: Breaking down multipart parsers: file upload validation bypass.
2025‑03‑22: A critical bibliography about the pirate site LibGen.
2025‑01‑23: See a PostgreSQL query, byte by byte, over TLS.
2024‑12‑04: Macros in the Dart programming language.
2025‑03‑28: Better Binary Quantization (BBQ) in Lucene and Elasticsearch.
2025‑04‑19: 15,000 lines of verified cryptography now in Python.
2025‑01‑03: The Intel Alder Lake SHLX anomaly.
2025‑01‑20: The "35-cent" Commodore 64 softmodem.
2025‑04‑15: A cautionary tale about continuity in constructive solid geometry.
2025‑04‑18: Probabilistic programming: doing statistics using the tools of computer science.
2021‑03‑19: Fuzzing TLS certificates from their ASN.1 grammar.
2025‑01‑24: Compile-time speed analysis of compiler frameworks for database query compilation.
2022‑01‑27: Two reasons Kubernetes is so complex.
2021‑05‑01: Internal combustion engine.
2024‑12‑23: My colleague Julius.
2024‑10‑03: Birth of the Bazel.
2024‑03‑08: You're wrong about the climate of tidally-locked planets.
2024‑04‑27: TOTP key URI format.
2024‑12‑05: Bicameral, not homoiconic.
2021‑08‑10: Three fundamental flaws of SIMD.
2025‑01‑18: Hands-on graphics with the NetBSD console.
2024‑05‑12: International meteor organization / international fireball program: amateur data collection of meteor events.
2024‑11‑01: Memento filter: a fast, dynamic, and robust range filter.
2021‑10‑12: Reproducible builds for Debian: a big step forward.
2025‑01‑04: Common Package Specification: a year closer to standard C++ dependency management.
2025‑02‑25: Proving a stupid sort algorithm with Dafny.
2025‑01‑30: A home built pipe organ.
2024‑06‑28: Misconceptions about static analysis of loops in C.
2024‑12‑26: Reads causing writes in PostgreSQL.
2024‑06‑19: How Vannevar Bush engineered the 20th century.
2025‑04‑18: NIST uncertainty machine.
2024‑09‑23: A Dieter Rams inspired iPhone bedside dock.
2022‑11‑20: Inside C++ boost::unordered_flat_map.
2024‑04‑09: Mac OS Grand Central Dispatch as a Rust async runtime.
2022‑01‑24: 11 pivotal moments in the history of timekeeping.
2025‑04‑20: Things Zig comptime won't do.
2021‑05‑04: How to solve the hardest logic puzzle ever.
2024‑09‑06: Async Rust can be a pleasure to work with (without Send + Sync + 'static).
2021‑12‑05: Votes for children! Why we should lower the voting age to six.
2025‑02‑16: Unexpected uses of the GF2P8AFFINEQB bit matrix multiply instruction.
2021‑05‑03: Simple as in SNMP.
2022‑08‑03: jlibtool: A replacement for libtool written in C.
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.