Tony Finch – link log

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‑06‑18: Posit floating point numbers: thin triangles and other tricks.
• 2025‑06‑13: jemalloc postmortem.
• 2025‑06‑12: A multivalued language with a dependent type system. (A precursor to Epic Verse.)
• 2025‑06‑10: Dependent types and program equivalence.
• 2025‑06‑08: Weaponizing dependabot: confused deputy pwn request at its finest.
• 2025‑06‑08: Simulating time with square-root space.
• 2025‑06‑06: Implementing dependent types in pi-forall.
• 2025‑06‑06: Hokusai Moyo Gafu: an album of dyeing patterns.
• 2025‑06‑05: IELR(1): practical LR(1) parser tables for non-LR(1) grammars with conflict resolution.
• 2025‑06‑04: DejaGNU (2011)
• 2025‑06‑04: Distance-based ISA for efficient register renaming.
• 2025‑06‑03: Zero-cost 'tagless initial' in Rust with GADT-style enums.
• 2025‑06‑03: What's higher-order about so-called higher-order references?
• 2025‑06‑03: How to take the inverse of a type.
• 2025‑06‑02: Pattern matching and exhaustiveness checking algorithms implemented in Rust.
• 2025‑06‑01: Tools built on tree-sitter's concrete syntax trees.
• 2025‑05‑31: Precision Clock Mk IV.
• 2025‑05‑31: Toxic Origins, Toxic Decisions: bias in CEO selection towards risk-taking, analysed using polluted Superfund sites.
• 2025‑05‑31: Beating the kCTF PoW with AVX512IFMA for $51k.
• 2025‑05‑30: Implementation of dependent types.
• 2025‑05‑29: ΠΣ: dependent types without the sugar.
• 2025‑05‑26: Type-level bounded recursion in Rust.
• 2025‑05‑26: Microsoft Windows Registry attack surface analysis.
• 2025‑05‑25: Bidirectional typing.
• 2025‑05‑24: There is no Diffie-Hellman but elliptic curve Diffie-Hellman.
• 2025‑05‑23: That fractal that's been up on my wall for 12 years.
• 2025‑05‑22: Designing APIs for humans: Stripe object IDs.
• 2025‑05‑22: Fast allocations in Ruby 3.5.
• 2025‑05‑22: Violating memory safety with Haskell's value restriction.
• 2025‑05‑22: Blazingly fast™ type class resolution with a trie.
• 2025‑05‑22: Violating memory safety with Haskell's value restriction.
• 2025‑05‑22: Gradients are the new intervals for signed distance function evaluation.
• 2025‑05‑21: The magic of software; or, what makes a good engineer also makes a good engineering organization.
• 2025‑05‑21: Dependent types at work in Agda.
• 2025‑05‑19: Modular type classes.
• 2025‑05‑18: PostgreSQL lock conflicts quick reference.
• 2025‑05‑17: The programming language that never was.
• 2025‑05‑17: Japan's IC cards are weird and wonderful.
• 2025‑05‑17: O2 VoLTE: locating any customer with a phone call.
• 2025‑05‑17: CHERIoT: the last ten years.
• 2025‑05‑17: Don’t use ISO/IEC 14977 Extended Backus-Naur Form (EBNF).
• 2025‑05‑17: Programming in Martin-Lof's type theory: an introduction. (1990)
• 2025‑05‑17: MicroHs: Haskell implemented with combinators by Lennart Augustsson.
• 2025‑05‑16: Pallene: a statically typed ahead-of-time compiled sister language to Lua, with a focus on performance.
• 2025‑05‑16: Lock-free Rust: how to build a rollercoaster while it’s on fire.
• 2025‑05‑16: From Haskell to a new structured combinator processor for graph reduction in hardware.
• 2025‑05‑16: Reservoir sampling: who discovered Algorithm R?
• 2025‑05‑16: Cloaca: a concurrent hardware garbage collector for non-strict functional languages.
• 2025‑05‑16: Initialization in C++ is seriously bonkers.
• 2025‑05‑15: A leap year check in three instructions.
• 2025‑05‑15: How did REST come to mean the opposite of REST?
• 2025‑05‑15: Fixing the traffic jam in the science of technology safety.
• 2025‑05‑15: Diagnosing a double-free concurrency bug in Rust's unbounded channels.
• 2025‑05‑15: 10 years of stable Rust: an infrastructure story.
• 2025‑05‑15: Crossness pumping station: seduced by symmetry.
• 2025‑05‑15: A Rust API inspired by Python, powered by Serde.
• 2025‑05‑14: The first year of free-threaded Python.
• 2025‑05‑14: Preventing outages with pkill's new --require-handler flag.
• 2025‑05‑13: YamlScriot: YAML done wisely.
• 2025‑05‑12: De Bruijn's combinatorics.
• 2025‑05‑12: Load-store conflicts.
• 2025‑05‑11: Alan Kay did not invent object-oriented programming.
• 2025‑05‑10: Castle Kellmore 2.5D rendering on the PlayDate handheld game console.
• 2025‑05‑10: Beating the fastest lexer generator in Rust.
• 2025‑05‑10: Stacking lookup tables in a lexer generator.
• 2025‑05‑09: Static interpretation of higher-order modules in Futhark: functional GPU programming in the large.
• 2025‑05‑08: Implement your programming language twice.
• 2025‑05‑07: The state of SSL/TLS stacks.
• 2025‑05‑06: A continuation-passing evaluation semantics for classical proofs.
• 2025‑05‑06: A formulae-as-type notion of control: classical logic and call/cc in Scheme.
• 2025‑05‑06: Propositions as types.
• 2025‑05‑05: Archers did not volley fire.
• 2025‑05‑05: Helmdar: 3D scanning Brooklyn on rollerblades.
• 2025‑05‑05: On the design of compact elastic binary trees (cebtree).
• 2025‑05‑04: Pixels in Islamic art: square Kufic calligraphy.
• 2025‑05‑02: Adaptive hashing in SBCL.
• 2025‑05‑02: Optimizing programs written in Guile Scheme.
• 2025‑05‑02: The one ring problem: abstraction and our quest for power.
• 2025‑05‑02: Elm property-based test case distributions.
• 2025‑05‑02: Designing type inference for high quality type errors.
• 2025‑05‑01: roons: modular marble logic.
• 2025‑05‑01: verb: Emacs org mode HTTP client.
• 2025‑04‑30: A collection of quotes on the design of notation as a tool of thought.
• 2025‑04‑30: BBC 1 logo 1985: a computer originated world.
• 2025‑04‑29: Let's Debug figures out why you can’t issue a certificate with Let's Encrypt.
• 2025‑04‑29: Syntactic musings on match expressions in Rust.
• 2025‑04‑27: DIY book lamp: simple electronics meets paper craft.
• 2025‑04‑27: Technical debt as theory building and practice.
• 2025‑04‑27: Silent bugs matter: a study of compiler-introduced security bugs.
• 2025‑04‑26: Visibly pushdown languages: between regular and context-free.
• 2025‑04‑26: Parallel ./configure
• 2025‑04‑26: Venera 8 Kosmos 482 descent craft reentry forecasts.
• 2025‑04‑25: The Bayeux Tapestry with knobs on: what do its 93 penises tell us?
• 2025‑04‑25: setenv() isn't threadsafe and even safe Rust didn't save us.
• 2025‑04‑25: Logarithms of algebraic data types for property-based testing.
• 2025‑04‑23: Danglepoise raise/lower dining table lights.
• 2025‑04‑23: What is cosh(List(Bool))? Or beyond algebra: analysis of data types.
• 2025‑04‑23: Does using Rust really make DNS name decompression safer?
• 2025‑04‑23: PiDP-11 and other replicas of old computers.
• 2025‑04‑23: Detecting if an expression is constant in C.
• 2025‑04‑20: Things Zig comptime won't do.
• 2025‑04‑19: Breaking down multipart parsers: file upload validation bypass.
• 2025‑04‑19: 15,000 lines of verified cryptography now in Python.
• 2025‑04‑18: Decomposing transactional systems.
• 2025‑04‑18: Marching Events: What does iCalendar have to do with ray marching?
• 2025‑04‑18: Sneak peek: A new ASN.1 API for Python.
• 2025‑04‑18: Exacerbating cross-site scripting: the iframe sandwich.
• 2025‑04‑18: NIST uncertainty machine.
• 2025‑04‑18: Dissolving the Fermi paradox.
• 2025‑04‑18: Squiggle: a simple programming language for intuitive probabilistic estimation.
• 2025‑04‑18: Probabilistic programming: doing statistics using the tools of computer science.
• 2025‑04‑17: An iOS dlsym() PAC calculation bug.
• 2025‑04‑17: The halting problem is a terrible example of NP-harder.
• 2025‑04‑16: Atomicless concurrency.
• 2025‑04‑16: Learning rate: What does it mean for a technology (such as solar power) to follow Wright’s Law?
• 2025‑04‑15: The .su ccTLD might be safe after all.
• 2025‑04‑15: Two years of Rust.
• 2025‑04‑15: Sunlight: a certificate transparency implementation built for scalability, ease of operation, and reduced cost.
• 2025‑04‑15: A cautionary tale about continuity in constructive solid geometry.
• 2025‑04‑15: Fun with -fsanitize=undefined and Picolibc.
• 2025‑04‑14: Flat origami is Turing complete.
• 2025‑04‑14: Clowns to the left of me, jokers to the right: dissecting and dividing algebraic data structures.
• 2025‑04‑13: Dijkstra on mathematical notation.
• 2025‑04‑12: Why is there a "small house" in IBM's code page 437?
• 2025‑04‑12: WebRTC for the curious.
• 2025‑04‑12: awe: A compiler for the Algol W programming language.
• 2025‑04‑11: What is algebraic about algebraic effects and handlers?
• 2025‑04‑11: London Cycle Orbital: peaceful cycling at London's margins.
• 2025‑04‑11: Why do AI company logos look like arseholes?
• 2025‑04‑11: The yaml document from hell.
• 2025‑04‑11: What do bodies think about?
• 2025‑04‑11: Situated software.
• 2025‑04‑10: A discipline of error handling.
• 2025‑04‑10: Practical UNIX manuals with mdoc: structure, style, and composition.
• 2025‑04‑09: facet: type reflection, serialization, deserialization — know the shape of your types in Rust.
• 2025‑04‑08: Obituary for Doug Lenat’s Cyc, the greatest monument to logical AGI.
• 2025‑04‑08: On the complexity and performance of parsing with derivatives.
• 2025‑04‑07: A rough survey of compilation, recompilation, and compile-time evaluation.
• 2025‑04‑06: How to sync anything.
• 2025‑04‑06: When should a Java JIT compiler expand garbage collection barriers?
• 2025‑04‑04: On JavaScript's weirdness.
• 2025‑04‑04: The crisis of zombie social science.
• 2025‑04‑03: How Java got the generics it has, or, how I learned to stop worrying and love type erasure.
• 2025‑04‑02: Gerrit, GitButler, and Jujutsu projects collaborating on a change-id commit footer.
• 2025‑04‑01: Electron band structure in germanium, my ass.
• 2025‑03‑31: WALI: WebAssembly with thin Linux kernel interfaces.
• 2025‑03‑31: There’s white stuff growing on your cheese that isn’t mold.
• 2025‑03‑31: LALRPOP: a parser generator for Rust.
• 2025‑03‑31: Incremental zero-config code navigation using stack graphs with tree-sitter at GitHub.
• 2025‑03‑31: comrak: a CommonMark and GFM compatible Markdown parser and renderer in Rust.
• 2025‑03‑31: sharun: run dynamically linked ELF binaries everywhere.
• 2025‑03‑31: Policy for the distribution of ISO publications and the protection of ISO’s copyright: ISO POCOSA 2012.
• 2025‑03‑30: Hacker laws, theories, principles, and patterns that developers will find useful.
• 2025‑03‑30: Towards fearless SIMD in Rust, 7 years later.
• 2025‑03‑30: Learn CSS layout the pedantic way.
• 2025‑03‑29: Compiler construction textbook by Niklaus Wirth.
• 2025‑03‑28: Better Binary Quantization (BBQ) in Lucene and Elasticsearch.
• 2025‑03‑28: Specifying Wasm with SpecTec.
• 2025‑03‑28: Wasm SpecTec has been adopted.
• 2025‑03‑28: Xee: a modern XPath and XSLT engine in Rust.
• 2025‑03‑27: RSS/Atom feed best practise.
• 2025‑03‑27: The Verilog preprocessor: force for `good and `evil
• 2025‑03‑26: Pi Pico Rx: a crystal radio for the digital age?
• 2025‑03‑26: Build better Golang release binaries.
• 2025‑03‑26: An epic treatise on error models for systems programming languages.
• 2025‑03‑25: On the ignorability of attributes in C++.
• 2025‑03‑25: Database protocols are underwhelming.
• 2025‑03‑24: faer: a general-purpose linear algebra library for Rust.
• 2025‑03‑24: CSS animation with offset-path.
• 2025‑03‑23: Carl Linnaeus's note-taking innovations.
• 2025‑03‑23: browse-at-remote: browse remote code forges with emacs.
• 2025‑03‑23: gif320: A GIF viewer for DEC VT320 terminals.
• 2025‑03‑22: Imberbus: a classic bus service across the Salisbury Plain to the lost village of Imber.
• 2025‑03‑22: A critical bibliography about the pirate site LibGen.
• 2025‑03‑22: SKIM: The implementation of functional languages using custom hardware.
• 2025‑03‑22: Brotli compression for the web.
• 2025‑03‑21: MySQL transactions per second vs fsyncs per second.
• 2025‑03‑21: Shaarli: personal, minimalist, super-fast, database free, bookmarking service.
• 2025‑03‑21: I want a good parallel computer.
• 2025‑03‑20: Fear and loathing of the English passive.
• 2025‑03‑18: y-cruncher: a multi-threaded Pi program.
• 2025‑03‑16: Performance of Git's new bundle-uri.
• 2025‑03‑16: Extracting content from an LCP “protected” ePub.
• 2025‑03‑15: Displaying Korean text efficiently.
• 2025‑03‑14: HashChain: a family of very fast factor-based sublinear exact-matching string search algorithms.
• 2025‑03‑14: Hash Chain: efficient exact online string search / matching through linked weak factors.
• 2025‑03‑14: PAM unixsock.
• 2025‑03‑13: Nanowar Of Steel - HelloWorld.java
• 2025‑03‑13: Triangle of power notation: exponents roots and logarithms.
• 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‑12: Constant-time code: the pessimist’s case.
• 2025‑03‑12: On the state of coherence in the land of type classes.
• 2025‑03‑12: Representing type lattices compactly.
• 2025‑03‑11: Owi: performant parallel symbolic execution made easy with OCaml and WebAssembly.
• 2025‑03‑11: Backyard cyanide from the cherry laurel.
• 2025‑03‑11: Far-UVC: germicidal ultraviolet light can inactivate a wide range of pathogens with minimal effects on human tissues.
• 2025‑03‑09: Performance of the Python 3.14 tail-call interpreter.
• 2025‑03‑09: Efficient communication and garbage collection in Haskell with compact normal forms.
• 2025‑03‑09: Keep calm and panic: performance of errors in Golang.
• 2025‑03‑09: Performance of returning errors vs. exceptions in Go and C++.
• 2025‑03‑07: JA4+: a suite of network fingerprinting standards.
• 2025‑03‑06: The Combined Cipher Machine, 1942-1962.
• 2025‑03‑05: Encoding Hangeul, Koreas writing system.
• 2025‑03‑04: Eradicating trivial vulnerabilities, at scale.
• 2025‑03‑02: Hardware discovery: ACPI and Device Tree.
• 2025‑03‑01: A dictionary of affixes: the building blocks of English.
• 2025‑02‑28: It's the latency, stupid!
• 2025‑02‑28: How CouchDB prevents data corruption with fsync.
• 2025‑02‑28: The Fibrovisor: a display made from a tat shop fibre-optic wand.
• 2025‑02‑28: Notes: long-form comments in GHC.
• 2025‑02‑27: But can DOOM run it? Programming satan’s computer.
• 2025‑02‑27: Can Doom run it? Adding with NAND gates in Doom.
• 2025‑02‑27: Socrates is a state machine: sans IO with async Rust.
• 2025‑02‑27: macOS tips and tricks.
• 2025‑02‑27: Efficient communication and collection with compact normal forms in Haskell.
• 2025‑02‑26: The miserable state of cellular modems and mobile network operators.
• 2025‑02‑25: Proving a stupid sort algorithm with Dafny.
• 2025‑02‑25: How core git developers configure git.
• 2025‑02‑22: How to write mathematics. (1973)
• 2025‑02‑22: Neut: a functional programming language with static memory management.
• 2025‑02‑20: A tail calling interpreter for Python, and other musttail updates.
• 2025‑02‑20: TRAVERTINE: CVE-2025-24118 safe memory reclamation race in the XNU Mac OS kernel.
• 2025‑02‑17: How does Ada's memory safety compare with Rust’s?
• 2025‑02‑17: 0+0 > 0: C++ thread-local storage performance.
• 2025‑02‑16: Program logics à la carte.
• 2025‑02‑16: Small-data computing: Hans-J Boehm’s correct calculator arithmetic.
• 2025‑02‑16: Unexpected uses of the GF2P8AFFINEQB bit matrix multiply instruction.
• 2025‑02‑16: Spin: formal verification of multi-threaded code.
• 2025‑02‑16: CPL elementary programming manual.
• 2025‑02‑16: Gaussian random number generators.
• 2025‑02‑15: Gorton recreations.
• 2025‑02‑15: Unofficial Jepsen test of Patroni, a PostgreSQL high availability solution.
• 2025‑02‑15: Gorton: The hardest working font in Manhattan.
• 2025‑02‑14: TeX and Typst layout models.
• 2025‑02‑14: Type safe variadic printf in Idris.
• 2025‑02‑14: Switching on strings in Zig.
• 2025‑02‑14: Intensional Joy: a concatenative account of internal structure.
• 2025‑02‑13: On Jujutsu and Magit.
• 2025‑02‑13: A fast 6502 code generator.
• 2025‑02‑11: Elementary functions NOT following the IEEE 754 floating-point standard.
• 2025‑02‑11: An approach to generate correctly rounded math libraries for new floating point variants.
• 2025‑02‑11: The `satisfies` operator in TypeScript.
• 2025‑02‑11: Optimal bounds for open addressed hash tables without reordering.
• 2025‑02‑10: Dazed and Confused: a large-scale real-world user study of reCAPTCHAv2.
• 2025‑02‑09: blip: A tool for seeing your Internet latency.
• 2025‑02‑09: Getting the type of a template argument as string in C++ without RTTI.
• 2025‑02‑08: From hours to 360ms: over-engineering a puzzle solution.
• 2025‑02‑08: Tips for mathematical handwriting.
• 2025‑02‑08: Fend: an arbitrary-precision unit-aware calculator.
• 2025‑02‑08: Turner, Bird, O’Neill, and the sieve of Eratosthenes.
• 2025‑02‑08: Colossus: the first large-scale electronic computer.
• 2025‑02‑08: Mustang: Rust programs written entirely in Rust.
• 2025‑02‑07: PolySubML: A simple ML-like language with subtyping, polymorphism, higher rank types, and global type inference.
• 2025‑02‑07: Rink: an open source unit-aware calculator.
• 2025‑02‑07: Numbat: A statically typed programming language for scientific computations with first class support for physical dimensions and units of measure.
• 2025‑02‑07: Profiling in production with function call traces.
• 2025‑02‑07: Periodic cooking of eggs.
• 2025‑02‑06: Three basic rules of safety hygiene in Rust.
• 2025‑02‑06: Thoughts after months of using Zig.
• 2025‑02‑05: The Sudoku affair.
• 2025‑02‑04: Delilah: Alan Turing’s secret wartime voice encryption project.
• 2025‑02‑04: Decorator JITs: Python as a DSL.
• 2025‑02‑04: No-panic Rust: a nice technique for systems programming.
• 2025‑02‑04: Notes on type layouts and ABIs in Rust.
• 2025‑02‑04: A developer’s philosophy.
• 2025‑02‑03: Pinning down "Future is not Send" errors in async Rust.
• 2025‑02‑03: A caveat with statically linked language runtimes.
• 2025‑02‑02: Hollywood: split a computer console into multiple panes of genuine technical melodrama.
• 2025‑02‑02: Introducing sealed capability types for CHERIoT.
• 2025‑02‑02: Parametric subtyping for structural parametric polymorphism.
• 2025‑02‑02: Conway's law: how do committees invent?
• 2025‑02‑02: An interview with James H Wilkinson: early numerical methods with electronic computers.
• 2025‑02‑01: Enabling Touch ID for sudo on macOS, before and after Sonoma.
• 2025‑01‑31: Jujutsu VCS introduction and patterns.
• 2025‑01‑31: Falsehoods programmers believe about null pointers.
• 2025‑01‑31: Byte queue limits for Linux network drivers.
• 2025‑01‑31: Why is unauthenticated encryption insecure?
• 2025‑01‑31: Adding garbage collection to our Rust-based interpreters with MMTk.
• 2025‑01‑30: A home built pipe organ.
• 2025‑01‑30: Scaling the Let’s Encrypt rate limits to prepare for a billion active TLS certificates.
• 2025‑01‑28: A retrospective on SCCS, the Source Code Control System.
• 2025‑01‑26: Use monoids for construction.
• 2025‑01‑25: The invalid 68030 instruction that accidentally allowed the Mac Classic II to successfully boot up.
• 2025‑01‑25: Advent of code 2024 in the BQN array programming language.
• 2025‑01‑25: Proper decoupling practices, and why you should leave 100nF behind.
• 2025‑01‑25: World's first MIDI shellcode: remote code execution on a synthesizer.
• 2025‑01‑24: Compile-time speed analysis of compiler frameworks for database query compilation.
• 2025‑01‑23: The mythical IO-bound Ruby on Rails app.
• 2025‑01‑23: Why PostgreSQL major version upgrades are hard.
• 2025‑01‑23: See a PostgreSQL query, byte by byte, over TLS.
• 2025‑01‑22: The London Underground is too hot, but it’s not an easy fix.
• 2025‑01‑22: Compiler fuzzing in continuous integration: a case study on Dafny.
• 2025‑01‑22: get_secrets: Negotiate symmetric secrets between two remote peers using mTLS secret exporter.
• 2025‑01‑22: How to unlock LUKS using Dropbear SSH keys remotely in Linux.
• 2025‑01‑22: Mercator: Extreme.
• 2025‑01‑21: The hunt for EINVAL in embedded Rust.
• 2025‑01‑20: InAppBrowser.com: see what JavaScript commands get injected.
• 2025‑01‑20: Hash function design, SMHasher and Goodhart's Law.
• 2025‑01‑20: The "35-cent" Commodore 64 softmodem.
• 2025‑01‑20: Automatic server reloading on change in Rust with listenfd and systemfd.
• 2025‑01‑19: The surprising struggle to get a UNIX epoch time from a UTC string in C or C++.
• 2025‑01‑19: Hasochism: the pleasure and pain of dependently typed haskell programming.
• 2025‑01‑18: Hands-on graphics with the NetBSD console.
• 2025‑01‑17: Responsible disclosure is wrong.
• 2025‑01‑17: Get a random selection of lines in a file using reservoir sampling in Rust.
• 2025‑01‑16: COW vs BEEF: busting the biggest etymology myth in linguistic history.
• 2025‑01‑16: ai.robots.txt: A list of AI agents and robots to block.
• 2025‑01‑16: ipcc-downloader: download iOS cellular carrier profiles.
• 2025‑01‑16: Is Wasm Memory64 actually worth using?
• 2025‑01‑16: The mess that is handling structure arguments and returns in LLVM.
• 2025‑01‑15: Fenwick trees are awesome!
• 2025‑01‑15: Das Blinkenlights!
• 2025‑01‑14: NREVERSAL of fortune: the thermodynamics of garbage collection.
• 2025‑01‑14: Phil Rogaway on radical computer science.
• 2025‑01‑13: Fluid simulation pendant.
• 2025‑01‑13: The missing JIT tier for SQL query compilers.
• 2025‑01‑13: Accurate benchmarking: how to account for the loop overhead.
• 2025‑01‑13: Underrated ways to change the world.
• 2025‑01‑13: Doug Lenat's source code for AM and EURISKO.
• 2025‑01‑12: exec-path-from-shell: Make Emacs use the $PATH set in your shell.
• 2025‑01‑12: Backdooring your backdoors: another $20 domain, more governments.
• 2025‑01‑12: From ASCII to ASIC: Porting donut.c to a tiny slice of silicon.
• 2025‑01‑12: What do long-term prices tell us about mineral resource scarcity?
• 2025‑01‑12: Why I chose Common Lisp.
• 2025‑01‑11: The double mmap() magic ring buffer.
• 2025‑01‑11: Rewrite it in Rust: a computational physics case study.
• 2025‑01‑11: Building Bauble: interactive signed distance functions with WebGL.
• 2025‑01‑11: Containerless plurals: separating number from type in object-oriented programming.
• 2025‑01‑11: Jef Raskin: Intuitive equals familiar. (1994)
• 2025‑01‑10: Bad Apple but it's 6,500 regexes that I search for in vim.
• 2025‑01‑10: How to miscompile programs with “benign” data races.
• 2025‑01‑10: Pushing the whole company into the past on purpose: deploying leap second smear at Facebook in 2015.
• 2025‑01‑10: Peter Kirstein describes how Britain got its first Internet connection.
• 2025‑01‑09: The design recipe from “how to design programs”.
• 2025‑01‑09: dnsclay: DNS UPDATE/AXFR/NOTIFY to many custom DNS operator APIs gateway
• 2025‑01‑09: SQL NULLs are weird!
• 2025‑01‑09: WorstFit: hidden transformations in Windows character sets.
• 2025‑01‑09: Rethinking errors, warnings, and lints.
• 2025‑01‑08: De-smarting the Marshall Uxbridge bluetooth speaker.
• 2025‑01‑08: Fidget: a library for representing implicit surfaces.
• 2025‑01‑07: Zig's comptime is bonkers good.
• 2025‑01‑07: Building ultra long range TOSLINK.
• 2025‑01‑06: Collatzeral damage: bitwise and proof foolish.
• 2025‑01‑06: Cray 1 supercomputer performance comparisons with home computers.
• 2025‑01‑06: Lord of the io_uring.
• 2025‑01‑05: D2: declarative diagramming, implemented in Golang.
• 2025‑01‑05: Academic urban legends: spinach as a source of iron.
• 2025‑01‑05: Don't clobber the frame pointer when writing asm for Golang.
• 2025‑01‑05: The evolution of tunnel boring machines.
• 2025‑01‑04: Phase behavior of Cacio e Pepe sauce.
• 2025‑01‑04: FIFO queues are all you need for cache eviction.
• 2025‑01‑04: UltraLogLog: a practical and more space-efficient alternative to HyperLogLog for approximate distinct counting.
• 2025‑01‑04: Common Package Specification: a year closer to standard C++ dependency management.
• 2025‑01‑04: 1ML: core and modules united.
• 2025‑01‑04: The state of Garnet in 2025.
• 2025‑01‑03: The Intel Alder Lake SHLX anomaly.
• 2025‑01‑03: Can PostgreSQL use this index, please?
• 2025‑01‑02: The Fish of Theseus port from C++ to Rust.
• 2025‑01‑01: How I helped fix sleep-wake hangs on Linux with AMD GPUs.
• 2024‑12‑31: Optimizing static search trees in Rust.
• 2024‑12‑30: Revealing peanut butter overheads with flame graphs.
• 2024‑12‑30: Concurrent cycle collection for Scheme in Rust.
• 2024‑12‑30: Adjust your sett: a tartan editor.
• 2024‑12‑29: SEninja: symbolic execution plugin for Binary Ninja.
• 2024‑12‑28: Ferris-on-Air: An experimental Wi-Fi stack for the ESP32 in Rust.
• 2024‑12‑28: An open-source Wi-Fi MAC layer for the ESP32.
• 2024‑12‑28: Von Neumann ordinals look like leaves.
• 2024‑12‑28: On Ada's dependent types, and its types as a whole.
• 2024‑12‑26: SpiNNaker: a million-core ARM machine. (2011)
• 2024‑12‑26: Rewriting the Ruby parser.
• 2024‑12‑26: Reads causing writes in PostgreSQL.
• 2024‑12‑25: When Unisys tried to cash in on GIF by charging royalties.
• 2024‑12‑24: Safety vs performance in C, C++, and Rust sort implementations.
• 2024‑12‑23: A worked example of copy-and-patch compilation.
• 2024‑12‑23: My colleague Julius.
• 2024‑12‑23: diman: A Rust library for checking units of measure at compile time.
• 2024‑12‑22: Blender USD scene import is accidentally quadratic.
• 2024‑12‑21: Stacked error handling for large Rust projects.
• 2024‑12‑21: The ugly truth about Spotify is finally revealed.
• 2024‑12‑21: Rules to avoid common extended inline assembly mistakes.
• 2024‑12‑21: A phantom memory leak that wasn't there.
• 2024‑12‑20: “Twelfth Night Till Candlemas: the story of a forty-year book-quest and of its remarkable ending.
• 2024‑12‑19: Fetching RSS/Atom feeds respectfully with curl.
• 2024‑12‑19: IPtables interactive diagram.
• 2024‑12‑19: Please stop citing TIOBE.
• 2024‑12‑17: Murder mystery: GCC builds failing after sbuild refactoring.
• 2024‑12‑17: Why did Silicon Valley turn right?
• 2024‑12‑16: Revisiting Hubris appconfigs.
• 2024‑12‑16: Crash recovery in Exhubris.
• 2024‑12‑16: OpenERV energy recovery ventilator.
• 2024‑12‑16: Parse me, baby, one more time: bypassing HTML sanitizers via parsing differentials.
• 2024‑12‑15: PopSec: how not to blow up a pipeline.
• 2024‑12‑15: Prequal: Load is not what you should balance.
• 2024‑12‑15: Mutation XSS explained, with a CVE and a challenge.
• 2024‑12‑13: vale: A markup-aware linter for prose.
• 2024‑12‑13: Thoughts on hashing in Rust.
• 2024‑12‑13: Things you never wanted to know about Golang interfaces.
• 2024‑12‑13: UNIX Review magazine interviews Larry Tesler.
• 2024‑12‑12: The Jujutsu version control system.
• 2024‑12‑12: Century-scale storage: If you had to store something for 100 years, how would you do it?
• 2024‑12‑11: Making memcpy(NULL, NULL, 0) well-defined.
• 2024‑12‑11: No NAT November: a month without IPv4.
• 2024‑12‑10: Gyroscopic Gyros.
• 2024‑12‑10: Common misconceptions about compilers.
• 2024‑12‑05: Faster SQL pagination with keysets, continued.
• 2024‑12‑05: Bicameral, not homoiconic.
• 2024‑12‑05: Implementing async APIs for microcontroller peripherals in Rust.
• 2024‑12‑05: The tragedy of Stafford Beer.
• 2024‑12‑04: Inheritance was invented as a performance hack in Simula.
• 2024‑12‑04: The Hoare cube.
• 2024‑12‑04: SQL OFFSET is worse than keyset pagination.
• 2024‑12‑04: Keyset cursors, not offsets, for pagination with PostgreSQL.
• 2024‑12‑04: OKLCH colour picker and converter.
• 2024‑12‑04: Macros in the Dart programming language.
• 2024‑12‑04: Egoless engineering.
• 2024‑12‑04: Francis Crick’s central dogma of genetics is not a "dogma," and it has never been broken.
• 2024‑12‑03: Filtered sampling from sorted values with randomized binary search.
• 2024‑12‑01: Typst as a programming language.
• 2024‑12‑01: DELETEs are difficult.
• 2024‑12‑01: Why do we call it "boilerplate code?"
• 2024‑11‑30: Compilation on the GPU? A feasibility study.
• 2024‑11‑30: Everything you never wanted to know about linker script.
• 2024‑11‑30: Combining git repos with josh-filter.
• 2024‑11‑29: Slow networking between cloud VMs on the same host.
• 2024‑11‑29: Using Pandoc and Typst to produce PDFs.
• 2024‑11‑29: Coded character sets history and development.
• 2024‑11‑28: Wislist for Linux from the mold linker's POV.
• 2024‑11‑28: MIT aluminium bicycle project 1974.
• 2024‑11‑27: if constexpr requires requires { requires } in C++.
• 2024‑11‑27: A collective of nouns.
• 2024‑11‑27: Emacs arbitrary code execution and how to avoid it.
• 2024‑11‑27: Structured editing and incremental parsing.
• 2024‑11‑27: The capacitor that Apple soldered incorrectly at the factory in the Macintosh LC III.
• 2024‑11‑27: Offpunk: an offline-first command-line web browser.
• 2024‑11‑27: Chawan: a web browser for your terminal.
• 2024‑11‑26: A solution to the onion problem of J. Kenji López-Alt.
• 2024‑11‑25: Theory-building and why employee churn is lethal to software companies.
• 2024‑11‑24: Mark–Scavenge garbage collection: waiting for the trash to take itself out.
• 2024‑11‑24: Anatomy of a thunk leak in Haskell.
• 2024‑11‑24: Petnames: A humane approach to secure decentralized naming.
• 2024‑11‑23: Why am I writing a JavaScript toolchain in Zig?
• 2024‑11‑23: copycat: intercept system calls using seccomp.
• 2024‑11‑22: Syntax error recovery in parsing expression grammars (PEG parsers).
• 2024‑11‑21: pv: pipe viewer progress bar.
• 2024‑11‑21: Handling cookies is a minefield.
• 2024‑11‑21: The stereographic projection of the Stern–Brocot tree.
• 2024‑11‑21: SQL, homomorphisms, and constraint satisfaction problems.
• 2024‑11‑21: Modern hardware for future databases.
• 2024‑11‑21: TIL: Some surprising code execution sources in bash.
• 2024‑11‑21: DBSP: automatic incremental view maintenance for rich query languages.
• 2024‑11‑21: Analytical anti-aliasing.
• 2024‑11‑20: Map keys and lifetimes in Rust.
• 2024‑11‑20: Railroad time in the USA started on 18 November 1883.
• 2024‑11‑20: How did software get so reliable without proof?
• 2024‑11‑20: Ghosts of departed proofs. (functional pearl)
• 2024‑11‑20: Type safety back and forth.
• 2024‑11‑20: Nominal types for storing, structural types for manipulating.
• 2024‑11‑20: Understanding the BM25 full text search algorithm.
• 2024‑11‑19: The thing about the Kobayashi Maru.
• 2024‑11‑19: In loving memory of the square checkbox.
• 2024‑11‑19: How many values does a boolean have?
• 2024‑11‑19: Adding Apple’s 🌐 globe key to a QMK-powered keyboard.
• 2024‑11‑17: Styling Graphviz with CSS.
• 2024‑11‑17: Urban Machine: robotics and AI to reclaim lumber for reuse.
• 2024‑11‑16: Nixie tubes.
• 2024‑11‑14: BetterBufRead: faster reads in Rust.
• 2024‑11‑13: Using portable SIMD in stable Rust.
• 2024‑11‑12: What does f(x) mean in C++?
• 2024‑11‑11: The CVM cardinality estimation algorithm.
• 2024‑11‑11: Row major vs. column major arrays, row vectors vs. column vectors.
• 2024‑11‑11: Precise inference of expressive units of measurement types.
• 2024‑11‑11: Type inference for units of measure.
• 2024‑11‑11: Far too many ways to wait on a child process with a timeout.
• 2024‑11‑10: Histogramming bytes with positional popcount, GF2P8AFFINEQB edition.
• 2024‑11‑10: Formalising graphs with coinduction in Agda.
• 2024‑11‑10: The design of a self-compiling C transpiler targeting POSIX shell.
• 2024‑11‑10: The principles of Mr. Harrison's longitude clock / maritime chronometer.
• 2024‑11‑10: Ferranti punched tape codes, including Flexowriter. (1961)
• 2024‑11‑10: RISC-V vector extension overview.
• 2024‑11‑09: Texture-less GPU text rendering.
• 2024‑11‑09: Known attacks and a primer on elliptic curve cryptography.
• 2024‑11‑09: Algol 68: a retrospective.
• 2024‑11‑08: The main features of CPL. (1963)
• 2024‑11‑08: The history of Standard ML ideas, principles, culture.
• 2024‑11‑08: The mechanical evaluation of expressions: Landin on the lambda calculus. (1964)
• 2024‑11‑08: CPL: failed venture or noble ancestor?
• 2024‑11‑08: Some proposals for improving the efficiency of ALGOL 60 — Strachey & Wilkes.
• 2024‑11‑07: Bringing faster stack unwinding exceptions to Rust.
• 2024‑11‑07: Rust's sneaky deadlock with `if let` blocks.
• 2024‑11‑07: Userland disk I/O.
• 2024‑11‑06: Mimic: a fast System/370 simulator for the IBM RT PC. (1987)
• 2024‑11‑05: Resurrection: the journal of the Computer Conservation Society.
• 2024‑11‑05: The Autocode programs developed for the Manchester University computers. (1958)
• 2024‑11‑05: The official Aztec C online museum.
• 2024‑11‑05: In search of types.
• 2024‑11‑04: IAU standards of fundamental astronomy.
• 2024‑11‑04: Macros, safety, and SOA (struct-of-arrays) in Rust.
• 2024‑11‑04: A Hamiltonian circuit for Rubik's Cube.
• 2024‑11‑04: C++, complexity, and compiler bugs.
• 2024‑11‑03: qcp: QUIC remote file copy.
• 2024‑11‑03: RRB vector: a practical general purpose immutable sequence.
• 2024‑11‑03: Rhombus: Racket’s new spin on macros without all the Scheme/Lisp parentheses.
• 2024‑11‑02: Breaking CityHash64, MurmurHash2/3, wyhash, and more...
• 2024‑11‑02: The ATS programming language: unleashing the potential of types and templates!
• 2024‑11‑02: Why PostgreSQL pg_dump is amazing.
• 2024‑11‑02: The Lounge: a‎ modern, responsive, cross-platform, self-hosted web IRC client in TypeScript.
• 2024‑11‑02: Scuttlebutt protocol guide.
• 2024‑11‑02: Strachey’s general purpose macrogenerator.
• 2024‑11‑01: Emacs org mode syntax cheat sheet.
• 2024‑11‑01: Unicode codepoints that expand or contract when case is changed in UTF-8.
• 2024‑11‑01: ActivityBot: a simple ActivityPub bot server in PHP.
• 2024‑11‑01: Memento filter: a fast, dynamic, and robust range filter.
• 2024‑11‑01: What is the point of an online conference?
• 2024‑11‑01: CIL: C intermediate language, a front end for linters.
• 2024‑11‑01: ASCII control characters in the terminal.
• 2024‑11‑01: Control characters in ASCII and Unicode.
• 2024‑10‑31: C++ ABI compatibility: the day the standard library died.
• 2024‑10‑30: Lessons learned from a successful Rust rewrite.
• 2024‑10‑30: ANSI C89
• 2024‑10‑30: malloc(0) & realloc(…，0) ≠ 0
• 2024‑10‑30: Five or ten new proofs of the Pythagorean theorem.
• 2024‑10‑29: TCP SYN spoofing attack directs abuse complaints at Tor relays.
• 2024‑10‑28: EBCDIC is incompatible with GDPR.
• 2024‑10‑28: Don’t implement unification by recursion.
• 2024‑10‑28: The widely cited studies on mouse vs. keyboard efficiency are completely bogus.
• 2024‑10‑28: OpenZFS deduplication is good now and you shouldn't use it.
• 2024‑10‑28: Old MacDonald had a barcode, E-I-EICAR.
• 2024‑10‑28: What’s new in POSIX 2024 XCU commands and utilities.
• 2024‑10‑27: A comparison of the C# and Rust borrow checkers.
• 2024‑10‑27: A new git-repack algorithm shrunk Microsoft’s Javascript monorepo git size by 94%.
• 2024‑10‑26: Before you buy a domain name, first check to see if it's haunted.
• 2024‑10‑25: A map of every road sign in the Netherlands.
• 2024‑10‑25: Bit twiddle hack: insert a 0 bit in the middle of a value.
• 2024‑10‑24: A line map for Milano's trams in TeX.
• 2024‑10‑24: Flatter wait-free hazard pointers.
• 2024‑10‑24: Linking directly to text fragments in web pages.
• 2024‑10‑24: Why write a new RTOS for CHERIoT?
• 2024‑10‑24: Zero or sign extend.
• 2024‑10‑24: A free, open source IPv6 textbook.
• 2024‑10‑23: Adding row polymorphism to Damas-Hindley-Milner.
• 2024‑10‑23: Breaking Bad: how compilers break constant-time cryptography implementations.
• 2024‑10‑23: Our optimizers need a rethink.
• 2024‑10‑22: Rustls outperforms OpenSSL and BoringSSL.
• 2024‑10‑22: A Mathematica interpreter in Typescript.
• 2024‑10‑22: Mathics: a free, open-source alternative to Mathematica.
• 2024‑10‑22: On the problem of naming things.
• 2024‑10‑21: A multithread concurrency cost hierarchy.
• 2024‑10‑21: The network is reliable? An informal survey of real-world communications failures.
• 2024‑10‑21: Jujutsu (jj) in practice.
• 2024‑10‑21: Learn Rust the dangerous way.
• 2024‑10‑20: Better defunctionalization through lambda set specialization.
• 2024‑10‑20: Responsive TOC leader lines with CSS.
• 2024‑10‑20: QUIC is not quick enough over fast internet.
• 2024‑10‑20: The origins of the term “daemon” in computing.
• 2024‑10‑20: Using Euro coins as standard weights.
• 2024‑10‑20: Jujutsu (jj), a git compatible version control system.
• 2024‑10‑19: Clapping Music for two flip-disc displays.
• 2024‑10‑18: superlinker: a tool for reinterpreting ELF executables and shared libraries.
• 2024‑10‑18: French supreme court decides about museums’ secret 3D scans of their sculptures.
• 2024‑10‑18: Understanding DNS resolution on Linux and Kubernetes.
• 2024‑10‑18: ugrapheme: Unicode extended grapheme clusters in nanoseconds with Python.
• 2024‑10‑18: The strange cases of consumer-grade routers on puny power supplies.
• 2024‑10‑17: Discovering features using HTTP OPTIONS.
• 2024‑10‑17: C89 draft standard in HTML.
• 2024‑10‑15: The origin and pronunciation of "GHIBLI".
• 2024‑10‑14: The beginnings of FM radio broadcasting.
• 2024‑10‑13: Silent CT: a quiet certificate transparency monitor.
• 2024‑10‑12: Exploring Typst, a new typesetting system similar to LaTeX.
• 2024‑10‑12: The road to OCIv2 images: what's wrong with tar?
• 2024‑10‑12: Ki: wireless power for kitchen appliances. (video)
• 2024‑10‑12: The ultimate conditional pattern matching syntax.
• 2024‑10‑11: Safety goggles for alchemists: the path towards safer transmute in Rust.
• 2024‑10‑11: Quantifying the Kevin Bacon game: a statistical exploration of Hollywood’s most connected actors.
• 2024‑10‑10: Why we’re helping more wikis move away from Fandom.
• 2024‑10‑10: Designing a fast concurrent hash table in Rust.
• 2024‑10‑10: A modest proposal: C++ resyntaxed. (1996)
• 2024‑10‑10: What is systems programming, really?
• 2024‑10‑09: 50 years of database queries.
• 2024‑10‑09: SQLite's use of Tcl.
• 2024‑10‑08: Five times ICANN deleted a ccTLD, and what it means for .io
• 2024‑10‑08: The origins of PostScript.
• 2024‑10‑08: Eidophor: 1950's space age video projection technology. (video)
• 2024‑10‑08: Tartufo searches through git repositories for high entropy strings and secrets.
• 2024‑10‑08: Z.200 CHILL: the ITU-T programming language.
• 2024‑10‑07: A general model for the origin of allometric scaling laws in biology.
• 2024‑10‑07: Big ball of mud: the de facto standard software architecture.
• 2024‑10‑07: AVX bitwise ternary logic and the Amiga blitter.
• 2024‑10‑07: Octothorpes: hashtags for the open Internet.
• 2024‑10‑06: The Gleam programming language is pragmatic.
• 2024‑10‑06: London Transport 25: ride 25 different forms of transport in one day.
• 2024‑10‑06: A fast revese linear scan register allocator for Cranelift.
• 2024‑10‑06: Playing with PostgreSQL and the BOLT linker layout optimizer.
• 2024‑10‑05: Towards standards for handwritten zero and oh: much ado about nothing (and a letter). (1967)
• 2024‑10‑05: The solid-state register allocator.
• 2024‑10‑05: PostScript 1.0: a code study.
• 2024‑10‑04: Persi Diaconis: Why did Markov invent Markov Chains? (video)
• 2024‑10‑04: Blessed.rs: an unofficial guide to the Rust crates ecosystem.
• 2024‑10‑04: "A=B", a book about computer methods of discovery and proof of hypergeometric identities.
• 2024‑10‑03: Birth of the Bazel.
• 2024‑10‑03: Terminal colours are tricky.
• 2024‑10‑03: Less htmx is more.
• 2024‑10‑02: Height hunt: a quest to find and visit every possible road vehicle height restriction sign in the UK.
• 2024‑10‑02: The fastest mutexes: Cosmopolitan libc and nsync.
• 2024‑10‑02: TigerBeetle code style.
• 2024‑10‑02: An introduction to the Filament hardware design language.
• 2024‑10‑01: Implementing virtual system calls with vDSO.
• 2024‑10‑01: The case of the missing increment: Golden Cove twice as fast as expected?!
• 2024‑10‑01: Kurt Vonnegut’s chess-like game GHQ.
• 2024‑09‑30: Beyond multi-core parallelism in Rust: faster Mandelbrot with SIMD.
• 2024‑09‑29: A p-adic representation of the rational numbers for fast easy arithmetic. (1979)
• 2024‑09‑28: The perils of transition to 64-bit time_t in Gentoo.
• 2024‑09‑27: Malicious SHA-1.
• 2024‑09‑26: Attacking UNIX systems via CUPS.
• 2024‑09‑26: Major leap for nuclear clock paves way for ultraprecise timekeeping.
• 2024‑09‑26: Rewriting Rust.
• 2024‑09‑25: A brief history of microprogramming.
• 2024‑09‑24: A few secure random bytes in PostgreSQL without pgcrypto.
• 2024‑09‑24: A busy beaver Collatz coincidence.
• 2024‑09‑24: Fully documented source code for Lander on the Acorn Archimedes.
• 2024‑09‑23: A Dieter Rams inspired iPhone bedside dock.
• 2024‑09‑23: An overview of cross-architecture portability problems.
• 2024‑09‑23: IO-Lite: a unified I/O buffering and caching system. (1999)
• 2024‑09‑23: “Truly hygienic” let statements in Rust.
• 2024‑09‑23: KGT (Kate’s grammar tool): BNF dialect converter and railroad diagram generator.
• 2024‑09‑22: The sorry state of Java deserialization.
• 2024‑09‑22: The roots of Work-as-Done and Work-as-Imagined.
• 2024‑09‑21: Questioning the criteria for evaluating non-cryptographic hash functions.
• 2024‑09‑21: The working archivist's guide to enthusiast CD-ROM archiving tools.
• 2024‑09‑21: Boolean blindness.
• 2024‑09‑21: The lost language extensions of MetaWare's High C compiler.
• 2024‑09‑19: Digital signatures and how to avoid them.
• 2024‑09‑19: 20 years later, real-time Linux makes it to the mainline kernel.
• 2024‑09‑19: Ruby-SAML pwned by XML signature wrapping attacks.
• 2024‑09‑18: Use IDENTITY columns instead of SERIAL in PostgreSQL.
• 2024‑09‑18: Database replication design spectrum.
• 2024‑09‑18: Handling 8kHz raw mouse input on Windows.
• 2024‑09‑18: Bézier curve arc length parametrizations.
• 2024‑09‑18: Emptying the dishwasher With systems theory.
• 2024‑09‑17: Watching letters: a history of Latvian orthography.
• 2024‑09‑17: Ratchets in software development.
• 2024‑09‑17: The centrality of stupidity in mathematics.
• 2024‑09‑16: Ante: A low-level functional language with algebraic effects and safe shared mutability.
• 2024‑09‑15: Turning disposable vapes into a fast charge power bank.
• 2024‑09‑15: AT&T’s CRISP Hobbits.
• 2024‑09‑15: A time consuming vDSO pitfall for 32-bit code on arm64 Linux.
• 2024‑09‑14: Speeding up Valkey to over 1M requests per second with memory prefetching.
• 2024‑09‑14: Porting SBCL to the Nintendo Switch.
• 2024‑09‑13: Energy after fire.
• 2024‑09‑12: smolweb HTML specification
• 2024‑09‑11: A short guide to the copyright wars.
• 2024‑09‑11: We spent $20 and accidentally became the admins of .MOBI
• 2024‑09‑10: Invisible salamanders are not what you think: AEAD’s lack of key commitment.
• 2024‑09‑10: Signatures are like backups.
• 2024‑09‑09: Debunking CISC vs RISC code density.
• 2024‑09‑09: A low-level look at A-normal form.
• 2024‑09‑09: What is the best pointer tagging method?
• 2024‑09‑08: Cracking an old ZIP file to help open source the ANC's "Operation Vula" secret crypto code.
• 2024‑09‑07: gRPC: the ugly parts.
• 2024‑09‑07: PERQ
• 2024‑09‑06: Async Rust can be a pleasure to work with (without Send + Sync + 'static).
• 2024‑09‑06: Massachusetts Bodged Transistor Authority: How we turned MBTA Red Line equipment into a car speedometer.
• 2024‑09‑05: Why eager languages don't have products and lazy languages don't have sums.
• 2024‑09‑04: LSP: the good, the bad, and the ugly.
• 2024‑09‑04: OptView2: inspect missed optimizations by LLVM clang.
• 2024‑09‑03: Is this Rust trait sealed or not?
• 2024‑09‑03: Unmaking the Makefiles: exorcising the Rust compiler test suite one file at a time.
• 2024‑09‑02: Parsing awk is tricky.
• 2024‑09‑01: A simple generic parallelism idiom and C++17 specifics.
• 2024‑09‑01: Raspberry Pi boot optimization: 3.5 sec to Linux userspace code.
• 2024‑09‑01: CHERIoT: a study in CHERI for RISC-V microcontrollers.
• 2024‑08‑31: CHERI myth: I don’t need CHERI if I have safe languages?
• 2024‑08‑31: Knepp rewilded.
• 2024‑08‑31: Fortran dot/comma bug urban legend.
• 2024‑08‑30: Bubble sort is not robust either.
• 2024‑08‑29: Your immune system is not a muscle.
• 2024‑08‑29: Compiling JavaScript to Wasm: partial evaluation, weval, and the first Futamura projection.
• 2024‑08‑29: Air Con: pay $1697 for an on/off switch, or fix the Android controller tablet?
• 2024‑08‑29: Two Turkish i dots too many.
• 2024‑08‑29: Rate limiting, ATM cells, and GCRA.
• 2024‑08‑29: Time-series compression algorithms, explained.
• 2024‑08‑29: Kahan’s lecture notes on the status of the IEEE Standard 754 for binary floating-point arithmetic.
• 2024‑08‑29: What every computer scientist should know about floating-point arithmetic.
• 2024‑08‑28: Examples of MVC for the Web.
• 2024‑08‑27: 5000x faster CRDTs: an adventure in optimization.
• 2024‑08‑27: MiniJinja: learnings from building a template engine in Rust.
• 2024‑08‑27: Don’t make fun of renowned author Dan Brown.
• 2024‑08‑27: Should scientific fraud and research misconduct be illegal?
• 2024‑08‑27: Using dtrace on MacOS with SIP enabled.
• 2024‑08‑27: Emulating x86 / amd64 on RISC-V.
• 2024‑08‑26: Poor foundations in geometric algebra.
• 2024‑08‑26: Writing a Rust compiler in C?!
• 2024‑08‑25: Linux pipes are slow.
• 2024‑08‑25: Old buildings in Cambridge.
• 2024‑08‑24: Printing the web: HTML and CSS for paper books.
• 2024‑08‑24: CORS is stupid: a guide to cookies and cross-origin request security.
• 2024‑08‑24: Geometric search trees.
• 2024‑08‑23: We need visual programming. No, not like that.
• 2024‑08‑23: Ted Dunning on histograms vs quantile sketches.
• 2024‑08‑23: Speeding up serde_json strings by 20%
• 2024‑08‑21: Which social media sites support which meta tags?
• 2024‑08‑19: Don't repeat yourself and the strong law of small numbers.
• 2024‑08‑18: How OCaml type checker works, or, what polymorphism and garbage collection have in common.
• 2024‑08‑18: The door problem: what does a game designer do?
• 2024‑08‑18: Techniques for safe garbage collection in Rust.
• 2024‑08‑17: MVCC: The part of PostgreSQL we hate the most.
• 2024‑08‑17: Replace Docker Compose with systemd, podman, and quadlet.
• 2024‑08‑16: How to write seemingly unhygienic and referentially opaque macros with Scheme syntax-rules.
• 2024‑08‑15: A non-uniform quasirandom number generator for games.
• 2024‑08‑15: A LaTeX-typeset reproduction of Reynolds' "Types, Abstraction and Parametric Polymorphism".
• 2024‑08‑15: A history of orthogonal frequency division multiplexing (OFDM).
• 2024‑08‑14: Incremental TT munchers: perhaps the most powerful macro parsing technique in Rust macro_rules.
• 2024‑08‑14: The medieval 'New England': a forgotten Anglo-Saxon colony on the north-eastern Black Sea coast.
• 2024‑08‑14: Round in circles and back again: Max Roberts updated London Underground concentric circles and spokes map.
• 2024‑08‑14: The soul of maintaining a new machine: communities of practice among Xerox photocopier repair engineers.
• 2024‑08‑14: spice: Fine-grained parallelism with sub-nanosecond overhead in Zig.
• 2024‑08‑13: Good retry, bad retry: an incident story.
• 2024‑08‑13: Division, modulus, and remainder for computer scientists.
• 2024‑08‑12: Hard drive disassembly: an IBM Deathstar from Nov. 2000.
• 2024‑08‑11: Rosie pattern language: modern text pattern matching to replace regex.
• 2024‑08‑11: The tic-tac-toe mysteries of Xerloc O'Xolmes.
• 2024‑08‑10: Rust on the RP2350.
• 2024‑08‑10: Confusion attacks: exploiting hidden semantic ambiguity in Apache httpd.
• 2024‑08‑08: Kyua graduates: The story behind the FreeBSD and NetBSD testing frameworks.
• 2024‑08‑08: A better light source for scanning color negative film.
• 2024‑08‑07: A trilingual inscription at Behistun near Persepolis led to the decipherment of cuneiform.
• 2024‑08‑07: Situated software.
• 2024‑08‑06: Building rqlite 9.0: cutting disk usage by half.
• 2024‑08‑04: Programming mantras are proverbs.
• 2024‑08‑04: Helmut Schmidt Future Prize acceptance speech by Meredith Whittaker.
• 2024‑08‑04: Git credential: password store integration for git-over-https
• 2024‑08‑03: There is (still) only one statistical test!
• 2024‑08‑03: Where do debuggers find shared library paths in core dumps?
• 2024‑08‑03: Primitive recursive functions for the working programmer.
• 2024‑08‑02: Another variable-length integer encoding.
• 2024‑08‑01: What your web framework never told you about SQL injection protection.
• 2024‑07‑31: Where does the name "algebraic data type" come from?
• 2024‑07‑30: Quint: An executable specification language with delightful tooling based on the temporal logic of actions (TLA).
• 2024‑07‑30: A skeptic's first contact with Kubernetes.
• 2024‑07‑30: Calculating the cost of a Google Deepmind paper, or, how to burn $10,000,000 on an arXiv preprint.
• 2024‑07‑29: How to build highly-debuggable C++ binaries.
• 2024‑07‑27: Unsafe read beyond of death: optimized short string SIMD load.
• 2024‑07‑27: Counting bytes faster with SIMD, interleaving, and prefetching.
• 2024‑07‑27: Driving compilers.
• 2024‑07‑26: CompilerFax: phone a compiler, fax it some code, it faxes back the results.
• 2024‑07‑26: Meta-Thunderbolt-Inception
• 2024‑07‑26: Rosemary Grant on the Galapagos finches: “Evolution happens much quicker than Darwin thought”.
• 2024‑07‑26: Color spaces: CIELAB, OKLAB, OKLCH.
• 2024‑07‑26: Why does the chromaticity diagram look like that?
• 2024‑07‑26: Please stop calling databases CP or AP.
• 2024‑07‑25: An extensive benchmark of C and C++ hash tables.
• 2024‑07‑22: Using algebra to refactor data types.
• 2024‑07‑22: From recursive descent to LR via Pratt parsing.
• 2024‑07‑21: How not to use box shadows.
• 2024‑07‑19: Concerns about passkeys.
• 2024‑07‑19: NSCopyObject, the griefer that keeps on griefing.
• 2024‑07‑19: The GNU make jobserver Implementation.
• 2024‑07‑18: Hash-based bisect debugging in compilers and runtimes.
• 2024‑07‑18: Why Polars rewrote its Arrow string data type.
• 2024‑07‑17: XSS injection using undeclared charset encoding and ISO-2022-JP sniffing.
• 2024‑07‑16: How the Stream Deck rose from the ashes of the legendary Optimus Maximus keyboard.
• 2024‑07‑16: Ethicswishing
• 2024‑07‑15: Pull requests via `git push`.
• 2024‑07‑15: Objective tests for aphantasia.
• 2024‑07‑13: git-pr: A new git collaboration service.
• 2024‑07‑12: Nine rules for successful power meetings.
• 2024‑07‑12: Beating the cache with value speculation.
• 2024‑07‑12: That afternoon headache is a sign of stale air.
• 2024‑07‑12: Are you sure you want to use mmap() in your database management system?
• 2024‑07‑11: tview: a Golang terminal UI library with rich, interactive widgets.
• 2024‑07‑11: Hash maps that don’t hate you.
• 2024‑07‑11: First contact with SQLite.
• 2024‑07‑10: Towards reproducible rebuilds of Debian packages.
• 2024‑07‑09: Is prefix of string in table? A journey into SIMD string processing.
• 2024‑07‑08: On understanding data abstraction, revisited.
• 2024‑07‑06: Properly property testing concurrent data structures.
• 2024‑07‑04: The X window system at 40.
• 2024‑07‑04: Beating NumPy's matrix multiplication in 150 lines of C.
• 2024‑07‑04: Sans-IO: The secret to effective Rust for network services.
• 2024‑07‑04: xsum: exactly-rounded summation of floating point values.
• 2024‑07‑04: nq: a command line job queue utility.
• 2024‑07‑03: The sad state of property-based testing libraries.
• 2024‑07‑02: BusyBeaver(5) is now proved to be 47,176,870.
• 2024‑07‑02: Losing the world record in HATETRIS.
• 2024‑06‑29: ChatGPT is bullshit.
• 2024‑06‑29: POSIX 2024 changes.
• 2024‑06‑29: Programming advice I’d give to myself 15 years ago.
• 2024‑06‑29: Bytecode breakdown: unraveling Factorio's Lua security flaws.
• 2024‑06‑29: A eulogy for DevOps.
• 2024‑06‑29: Devops: the funeral.
• 2024‑06‑28: gRPC: the bad parts.
• 2024‑06‑28: Misconceptions about static analysis of loops in C.
• 2024‑06‑27: Valve.Computer: A modern 8 bit design, built using 1950s thermionic valves.
• 2024‑06‑27: OpenSSL CVE-2024-5535: `SSL_select_next_proto` buffer overread.
• 2024‑06‑26: Why I attack.
• 2024‑06‑26: Rigorous numerical integration in Arb.
• 2024‑06‑26: Profiling with ctrl-C.
• 2024‑06‑26: The many faces of undefined in JavaScript.
• 2024‑06‑25: Re-creating early generative art: Schotter, by Georg Nees.
• 2024‑06‑25: Sans I/O when the rubber meets the road.
• 2024‑06‑25: The magic of participatory randomness.
• 2024‑06‑25: Network protocols, sans I/O.
• 2024‑06‑24: ChocoPy: a subset of Python 3 for teaching compiler construction.
• 2024‑06‑24: Rust’s new sort algorithms.
• 2024‑06‑24: Resolving metastability issues during bootstrapping CLOS.
• 2024‑06‑23: How to design a CPU ISA (instruction set architecture).
• 2024‑06‑23: Why is AVX 512 useful for the RPCS3 PlayStation 3 emulator?
• 2024‑06‑23: A history of Psion and Symbian.
• 2024‑06‑22: Overlays get ignored.
• 2024‑06‑22: Optimizing SQLite for servers.
• 2024‑06‑22: The simple essence of algebraic subtyping: principal type inference with subtyping made easy.
• 2024‑06‑21: 1/25-scale Cray C90 wristwatch.
• 2024‑06‑21: Reflections on software performance.
• 2024‑06‑20: How to use the new counted_by attribute in C and Linux.
• 2024‑06‑20: Avoiding the top 10 NGINX configuration mistakes.
• 2024‑06‑20: Public JavaScript CDNs are useless and dangerous.
• 2024‑06‑20: The full-source bootstrap: building from source all the way down.
• 2024‑06‑19: How Vannevar Bush engineered the 20th century.
• 2024‑06‑19: Demystifying Rust's ? operator and Try trait.
• 2024‑06‑18: Peak population projections.
• 2024‑06‑18: I’ve stopped using box plots. Should you?
• 2024‑06‑18: Box plots are the better default choice for visualizing performance.
• 2024‑06‑18: Avoiding Emacs bankruptcy.
• 2024‑06‑18: Equality has more than one meaning in mathematics.
• 2024‑06‑17: Zig-style generics are not well-suited for most languages.
• 2024‑06‑17: Making robots plan faster with SIMD and Rust.
• 2024‑06‑17: The ineffable types of Rust: how to make self-borrows safe.
• 2024‑06‑16: MicroMac, a 128k Macintosh emulated on an RP2040.
• 2024‑06‑16: There are only three frequencies: never, sometimes, always.
• 2024‑06‑16: Generators vs list comprehensions with join() in Python.
• 2024‑06‑16: Stupid TLS facts: session resumption.
• 2024‑06‑16: Reconstructing public keys from cryptographic signatures.
• 2024‑06‑16: The story of reformatting 100k source files at Google in 2011.
• 2024‑06‑15: Exponentially better rotations.
• 2024‑06‑15: Pitfalls of PostgreSQL logical decoding.
• 2024‑06‑13: Whose CIDR is it anyway? Scanning all of whois and rdap.
• 2024‑06‑13: Chaos in the medium: watercolour plotting.
• 2024‑06‑13: Crafting an interpreter with Rust.
• 2024‑06‑13: Understanding DNS in Kubernetes.
• 2024‑06‑12: Bamboo can be as invasive as Japanese knotweed.
• 2024‑06‑12: Breaking AES-GCM on nonce reuse.
• 2024‑06‑12: Inside Mexico’s anti-avocado militias.
• 2024‑06‑11: Characterizing the Raspberry Pi Pico RP2040 ADC.
• 2024‑06‑11: Forsp: a Forth+Lisp hybrid CBPV language.
• 2024‑06‑10: Dangers of newlines in inline assembly.
• 2024‑06‑09: Using HDMI EMI for fast wireless data transfer.
• 2024‑06‑09: Ultrasonic investigations in shopping centres.
• 2024‑06‑09: A (draft) taxonomy of SIMD usage.
• 2024‑06‑09: How many High Streets are there in London?
• 2024‑06‑08: Towards federated key transparency.
• 2024‑06‑08: A fast alternative to the modulo reduction.
• 2024‑06‑08: Fibonacci hashing: the optimization that the world forgot (or: a better alternative to integer modulo).
• 2024‑06‑08: Compilers are (too) smart: a failed popcount optimization.
• 2024‑06‑07: What is PID 0?
• 2024‑06‑07: Leopard-free programming.
• 2024‑06‑07: Leveraging Zig's allocators.
• 2024‑06‑07: Tom7’s BoVeX typesetter with AI-assisted justified text.
• 2024‑06‑07: Speeding up rustc by being lazy.
• 2024‑06‑06: lelwel: a resilient LL(1) parser generator for Rust.
• 2024‑06‑06: let rand = main as usize;
• 2024‑06‑06: Shortcat: Manipulate macOS masterfully, minus the mouse.
• 2024‑06‑06: TPM GPIO fail: how bad OEM firmware ruins TPM security.
• 2024‑06‑06: First steps with DHCPv6-PD on OpenBSD.
• 2024‑06‑06: Propagating bounds through bitwise operations in abstract interpretation.
• 2024‑06‑04: Simple proofs with Z3Py.
• 2024‑06‑04: Why do electronic components have such odd values? Renard numbers and ISO 3.
• 2024‑06‑04: Codd almighty! 50 years of SQL.
• 2024‑06‑04: Cloning-based context-sensitive pointer alias analysis using binary decision diagrams in bddbddb.
• 2024‑06‑04: bddbddb: using Datalog with binary decision diagrams for program analysis.
• 2024‑06‑04: Sound, precise, and fast abstract interpretation with tristate numbers.
• 2024‑06‑04: Bit-twiddling abstract addition with unknown bits.
• 2024‑06‑04: You will regret using natural keys.
• 2024‑06‑04: LL and LR in context: why parsing tools are hard.
• 2024‑06‑04: automemcpy: a framework for automatic generation of fundamental memory operations.
• 2024‑06‑03: {fmt}: a modern C++ string formatting library.
• 2024‑06‑02: Tiny Tapeout: an educational project to get your designs manufactured on a real chip.
• 2024‑06‑02: For want of a relative path to ld.so
• 2024‑06‑02: Tock: an embedded operating system in Rust.
• 2024‑06‑02: The borrow checker within Rust.
• 2024‑06‑02: Rust and dynamically-sized thin pointers.
• 2024‑06‑01: Rust regex engine internals as a library.
• 2024‑06‑01: Performance culture.
• 2024‑06‑01: X is justifiably slow?
• 2024‑06‑01: Electromagnetic linear clock.
• 2024‑05‑31: The greatest clock (and map) ever made.
• 2024‑05‑30: Ultrasonic cold brew coffee.
• 2024‑05‑30: Why, after 6 years, I’m over GraphQL.
• 2024‑05‑29: Recycling steel with cement in an arc furnace could produce zero-emissions concrete.
• 2024‑05‑29: Rhodes must fall: The legacy of Cecil Rhodes in the University of Oxford.
• 2024‑05‑29: Why rejecting invalid XML in the browser is a bad idea.
• 2024‑05‑28: A study of MAC address randomization in mobile devices and when it fails.
• 2024‑05‑28: Surveilling the masses with Wi-Fi-based positioning systems.
• 2024‑05‑28: I’ve womansplained him to death.
• 2024‑05‑28: Your web API shouldn't redirect HTTP to HTTPS.
• 2024‑05‑28: aa-56: an astronomical ephemeris calculator program.
• 2024‑05‑28: The Cephes mathematical library.
• 2024‑05‑28: TerminalTextEffects: a visual effects engine for xterm-compatible terminal emulators.
• 2024‑05‑28: IPv6 link-local stunts: ping ff02::1 etc.
• 2024‑05‑28: Programming pearls: Bumper sticker computer science.
• 2024‑05‑28: Why software projects take longer than you think: a statistical model.
• 2024‑05‑28: Doing is normally distributed, learning is log-normal.
• 2024‑05‑28: Wasmi WebAssembly interpreter’s new execution engine.
• 2024‑05‑27: Reclaiming IPv4 Class E 240.0.0.0/4.
• 2024‑05‑26: Statically typed functional programming with Python 3.12.
• 2024‑05‑26: RuSSH: a Rust SSH client and server library.
• 2024‑05‑26: Extend your battery life with the scx_rustland Linux scheduler.
• 2024‑05‑26: Taming floating-point sums with Rust.
• 2024‑05‑26: Hurl: an exceptional programming language.
• 2024‑05‑21: vu128: Efficient variable-length integers
• 2024‑05‑21: Rust's iterators optimize nicely—and contain a footgun.
• 2024‑05‑19: I am too old to create a popular programming language.
• 2024‑05‑19: How often is the wife taller than the husband?
• 2024‑05‑19: polyfill-glibc: patch Linux executables for compatibility with older glibc.
• 2024‑05‑19: AOT JS compilation by wevaling the wasms.
• 2024‑05‑19: Compilers for free with weval, a wasm partial evaluator.
• 2024‑05‑19: VirusTotal YARA has been rewritten in Rust as YARA-X.
• 2024‑05‑18: Why writing correct software is hard.
• 2024‑05‑18: Fix your video game’s timestep!
• 2024‑05‑18: Fixing iterative damping interpolation in video games.
• 2024‑05‑18: TCP performance and the Mathis equation.
• 2024‑05‑18: Practical third-party library sandboxing with RLBox.
• 2024‑05‑17: The rainbow hats puzzle.
• 2024‑05‑17: Golang disables Nagle’s algorithm, making it evil on shitty networks.
• 2024‑05‑17: Existential types in Rust.
• 2024‑05‑17: A transport protocol's view of Starlink.
• 2024‑05‑17: What even is a pidfd anyway?
• 2024‑05‑16: History of the Italian electrical system.
• 2024‑05‑16: A look at the Mojo language for bioinformatics.
• 2024‑05‑16: Strings in Julia vs Rust: you probably don't need to validate UTF-8.
• 2024‑05‑16: D3 in depth.
• 2024‑05‑16: Understanding misunderstandings in C source code using IOCCC winners.
• 2024‑05‑16: Ebury is alive but unseen: 400k Linux servers compromised by the Windigo group.
• 2024‑05‑16: Some notes on Rust, mutable aliasing, and formal verification.
• 2024‑05‑15: Sir, there's a cat in your mirror dimension.
• 2024‑05‑15: A tale of two sieves.
• 2024‑05‑15: The creator of Magic: The Gathering knows exactly where it all went wrong.
• 2024‑05‑14: Optimizing the Roc parser/compiler with data-oriented design.
• 2024‑05‑14: A triad of factors that explain the nature of software.
• 2024‑05‑13: How to include Git version information in a Golang binary.
• 2024‑05‑13: Submitting a Linux kernel patch with b4.
• 2024‑05‑13: Exploring GNU C extensions in the Linux kernel.
• 2024‑05‑13: Parsing JSON is a minefield.
• 2024‑05‑12: The alternative programming language implementation problem.
• 2024‑05‑12: GPUs go brrr: how to keep the nVIDIA H100 tensor cores fed.
• 2024‑05‑12: Functional semantics in imperative clothing in the Roc programming language.
• 2024‑05‑12: Can we make bicycle manufacturing sustainable again?
• 2024‑05‑12: Emoji history: the missing years.
• 2024‑05‑12: Garbage collectors are scary.
• 2024‑05‑12: Breaking DKIM and BIMI in 2024 using the Debian OpenSSL bug CVE-2008-0166.
• 2024‑05‑12: International meteor organization / international fireball program: amateur data collection of meteor events.
• 2024‑05‑11: In Rust, methods should be object safe.
• 2024‑05‑11: Why the CORDIC algorithm lives rent-free in my head.
• 2024‑05‑11: Thread: the wireless tech we can't use or teach.
• 2024‑05‑09: ppstep: an interactive C/C++ preprocessor macro debugger.
• 2024‑05‑09: It's always TCP_NODELAY. Every damn time.
• 2024‑05‑09: Rust through the ages.
• 2024‑05‑09: Scanners work fine over iSCSI.
• 2024‑05‑09: datatype99: algebraic data types for C99.
• 2024‑05‑09: Needle: a DFA regex library that compiles to JVM bytecode.
• 2024‑05‑09: The await event horizon in JavaScript.
• 2024‑05‑08: B612: the Airbus cockpit display font.
• 2024‑05‑08: The C preprocessor iceberg.
• 2024‑05‑07: A 100x speedup with unsafe Python.
• 2024‑05‑07: Secure Randomness in Golang 1.22.
• 2024‑05‑07: Search has been put in the vibe space.
• 2024‑05‑06: JTAG hacking with a Raspberry Pi: introducing the PiFex.
• 2024‑05‑06: How to successfully rewrite a C++ codebase in Rust.
• 2024‑05‑06: Pair your compilers at the ABI café.
• 2024‑05‑06: Decoding UTF8 with the pext parallel extract instruction.
• 2024‑05‑06: The C++ iceberg.
• 2024‑05‑05: An extended subtweet on power-over, vs power-with or power-to.
• 2024‑05‑05: The Italian streets that don't exist on any map.
• 2024‑05‑05: Thinking is bad: implications of human error research for spreadsheet research and practice.
• 2024‑05‑05: How to build a $20 billion semiconductor fab.
• 2024‑05‑05: Byte magazine August 1983: The C Language.
• 2024‑05‑05: Bit-stealing made legal: compilation for custom memory representations of algebraic data types.
• 2024‑05‑05: TypeID: type-safe, K-sortable, globally unique identifiers.
• 2024‑05‑05: Understanding Stein's paradox in higher-dimensional statistics.
• 2024‑05‑04: Interview with Donald Knuth, with his opinions on multicore CPUs.
• 2024‑05‑03: ECDH-OMR: elliptic curve Diffie-Hellman oblivious message retrieval.
• 2024‑05‑02: Hobby’s algorithm for aesthetic Bézier splines.
• 2024‑05‑02: Piccolo: a stackless Lua interpreter in Rust.
• 2024‑05‑02: TestResult: a Rust error type that panics early.
• 2024‑05‑02: Designing an efficient memory layout in Rust with unsafe and unions, or, an overlong guide in avoiding dynamic dispatch.
• 2024‑05‑02: Unwind considered harmful?
• 2024‑05‑02: The world's loudest Lisp program, for tunnel evacuation.
• 2024‑05‑02: PaperWM.spoon: tiled scrollable window manager for Hammerspoon on MacOS.
• 2024‑05‑01: It's time to stop recommending Clean Code.
• 2024‑04‑30: Rink: an open source unit-aware calculator.
• 2024‑04‑30: iRRAM: exact arithmetic in C++.
• 2024‑04‑30: PostgreSQL supported platforms over time.
• 2024‑04‑30: Bytecode VMs in surprising places.
• 2024‑04‑30: PowerShell monad manifesto.
• 2024‑04‑30: State of the terminal.
• 2024‑04‑30: A random walk through the Ada programming language.
• 2024‑04‑29: So, you want to write an unsafe crate in Rust?
• 2024‑04‑29: fend: an arbitrary-precision unit-aware calculator.
• 2024‑04‑29: The space bar stabilizer problem.
• 2024‑04‑29: FreeBee: AT&T 3B1 UNIX PC emulator.
• 2024‑04‑29: Thorium nucleus excited with laser: a breakthrough after decades.
• 2024‑04‑29: Bloat busters: pg_repack vs pg_squeeze.
• 2024‑04‑29: Principles for keyboard layouts.
• 2024‑04‑29: Importing ECMAscript modules with require() in node.js.
• 2024‑04‑29: WireGuard endpoints and IP addresses.
• 2024‑04‑29: Simple NDP proxy to route your IPv6 VPN addresses.
• 2024‑04‑28: The invention of the integrated circuit recorded in Jean Hoerni's patent notebook.
• 2024‑04‑28: Synth wars: The story of MIDI, the one interface that ruled them all.
• 2024‑04‑28: Building an IBM 3270 terminal controller.
• 2024‑04‑27: Tasks are the wrong abstraction for async Rust.
• 2024‑04‑27: TOTP key URI format.
• 2024‑04‑26: Captain Zilog crushed! The story of the Z8000.
• 2024‑04‑26: Passkeys: a shattered dream.
• 2024‑04‑25: The weird world of Windows file paths.
• 2024‑04‑25: Why does Windows use backslash as its path separator?
• 2024‑04‑24: How web bloat impacts users with slow devices.
• 2024‑04‑24: So you want to learn to break ciphers?
• 2024‑04‑24: Digitized continuous magnetic recordings of the Carrington event from Greenwich and Kew.
• 2024‑04‑23: A photo album of space age consumer electronics.
• 2024‑04‑23: Inside the Super Nintendo cartridges.
• 2024‑04‑23: The bubble sort curve.
• 2024‑04‑23: No one buys books.
• 2024‑04‑22: Manual for Larry Tesler’s PUB markup language. (1971)
• 2024‑04‑20: Microsoft Windows denial of service by Hisense TV.
• 2024‑04‑19: A history of parsers of the Ruby programming language.
• 2024‑04‑19: Cable maintenance ships: The invisible seafaring industry that keeps the internet afloat.
• 2024‑04‑19: Raw flux streams and obscure formats: Further work around imaging 5.25-inch floppy disks.
• 2024‑04‑18: Formal methods: just good engineering practice?
• 2024‑04‑18: UCAM-CL-TR-988: CHERI C semantics as an extension of the ISO C17 standard.
• 2024‑04‑18: Formal mechanised semantics of CHERI C: capabilities, undefined behaviour, and provenance.
• 2024‑04‑18: A domino computer.
• 2024‑04‑17: Feathers are one of evolution’s cleverest inventions.
• 2024‑04‑17: Will we have a negative leap second?
• 2024‑04‑17: The hardest problem in web design: centering things.
• 2024‑04‑16: Some useful types for database-using Rust web apps.
• 2024‑04‑16: Etak Navigator: how they made a mapping computer in the 1980s.
• 2024‑04‑15: Five little languages and how they grew: Dennis Ritchie’s talk at HOPL on the history of C.
• 2024‑04‑14: Sandboxing all the things with Flatpak and BubbleBox.
• 2024‑04‑14: sotrace: show hidden dependencies in Linux binaries.
• 2024‑04‑13: Transcript of Martha Wells’ Jack Williamson Lecture 2024, on MurderBot.
• 2024‑04‑11: The simple beauty of XOR floating point time series compression.
• 2024‑04‑11: Subclassing in Python, redux.
• 2024‑04‑11: A simple derivation of sin and cos by stacking triangles.
• 2024‑04‑10: A memory of the nineteen-nineties, by Teller.
• 2024‑04‑10: Steve Klabnik's Jujutsu tutorial.
• 2024‑04‑10: BatBadBut: You can't securely execute commands on Windows.
• 2024‑04‑09: Mac OS Grand Central Dispatch as a Rust async runtime.
• 2024‑04‑09: Halbach magnetic array.
• 2024‑04‑09: The link between abortion and crime.
• 2024‑04‑09: How I tripped over the Debian weak keys vulnerability.
• 2024‑04‑09: path.join considered harmful, or openat() all the things.
• 2024‑04‑09: An introduction to jump threading optimizations in gcc.
• 2024‑04‑09: Concurrency vs paralellism.
• 2024‑04‑09: The server chose violence: error handling in the Hubris embedded OS.
• 2024‑04‑08: Excuse me sir, would you like to buy a kilo of isopropyl bromide?
• 2024‑04‑08: It's time for operating systems to rediscover hardware.
• 2024‑04‑08: Putting out the hardware dumpster fire.
• 2024‑04‑05: The state of time in Rust: leaps and bounds.
• 2024‑04‑05: Features I wish PostgreSQL had as a developer.
• 2024‑04‑05: The case against self-closing tags in HTML.
• 2024‑04‑05: Switching to the meow modal editing system from evil emacs.
• 2024‑04‑04: Conway's Game of Life through time.
• 2024‑04‑04: The V8 sandbox.
• 2024‑04‑04: HTTP/2 CONTINUATION flood denial of service vulnerability.
• 2024‑04‑04: CHERIoT and supply chain security.
• 2024‑04‑04: Putting an xz backdoor payload in a valid RSA key.
• 2024‑04‑03: Cowgol: an experimental, Ada-inspired language for 8 bit micros.
• 2024‑04‑03: Diff modulo base, for comparing rebased branches.
• 2024‑04‑03: Multiple cursors for emacs.
• 2024‑04‑01: The Wi-Fi only works when it's raining?!
• 2024‑04‑01: When concurrency matters: behaviour-oriented concurrency.
• 2024‑04‑01: The muscular imagination of Iain M. Banks: a future you might actually want to live in.
• 2024‑03‑31: A kinematically coupled piezo nanometer-resolution microscope focus stage.
• 2024‑03‑31: Changes to `u128`/`i128` layout in Rust.
• 2024‑03‑31: Countering trusting trust.
• 2024‑03‑31: A systematic analysis of the Juniper Dual EC DRBG backdoor.
• 2024‑03‑30: Basic things to support your software project.
• 2024‑03‑30: The "not rocket science" rule of continuous integration (and the story of monotone and bors).
• 2024‑03‑30: Xz format inadequate for long-term archiving.
• 2024‑03‑29: Could ice cream possibly be good for you?
• 2024‑03‑29: A new provisioning tool built with mgmt.
• 2024‑03‑28: TCP is an underspecified two-node consensus algorithm and what that means for your proxies.
• 2024‑03‑28: Binary Fuse Filters: fast and smaller than xor filters.
• 2024‑03‑27: Who killed the network switch? An embedded Rust debugging story.
• 2024‑03‑26: Preventing cross-service UDP loops in QUIC.
• 2024‑03‑25: Interval parsing grammars for file format parsing.
• 2024‑03‑23: Unexplanations: SQL is syntactic sugar for relational algebra. (not!)
• 2024‑03‑21: Progressing towards the redefinition of the second based on an optical frequency standard.
• 2024‑03‑21: A giant leap for the leap second. Is humankind ready?
• 2024‑03‑21: Bug hunting in btrfs.
• 2024‑03‑19: The invention of fuzz testing.
• 2024‑03‑15: JESK56: a diodeless keyboard matrix derived using graph theory.
• 2024‑03‑13: Mu-Ency: the encyclopedia of the Mandelbrot set.
• 2024‑03‑12: Identifying software: supply chain security with GNU Guix.
• 2024‑03‑12: yet-another-cad-viewer: display OCP/CadQuery/Build123d models in a web browser.
• 2024‑03‑11: Staged generic programming.
• 2024‑03‑11: A practical unification of multi-stage programming and macros.
• 2024‑03‑10: Do Be Do Be Do, or, Frank: a strict functional programming language with algebraic effects.
• 2024‑03‑10: Compiling without continuations.
• 2024‑03‑10: Learning lessons from the cyber-attack: British Library cyber incident review.
• 2024‑03‑10: Kinds are calling conventions.
• 2024‑03‑09: Call-by-push-value: decomposing call-by-value and call-by-name.
• 2024‑03‑09: Call-by-push-value. (1999)
• 2024‑03‑09: I'm betting on call-by-push-value.
• 2024‑03‑09: SuperC: parsing all of C by taming the preprocessor.
• 2024‑03‑09: The SuperC parsing framework.
• 2024‑03‑08: A flexible and economical UTF-8 decoder.
• 2024‑03‑08: USAF computer security technology planning study: memory safety bugs in 1972.
• 2024‑03‑08: You're wrong about the climate of tidally-locked planets.
• 2024‑03‑07: CAP twelve years later: how the "rules" have changed.
• 2024‑03‑07: The CAP theorem: the bad, the bad, and the ugly.
• 2024‑03‑06: Conway’s Law: the only unbreakable law.
• 2024‑03‑06: How I use git worktrees.
• 2024‑03‑06: Use weird tests to capture tacit knowledge.
• 2024‑03‑06: Maybe everything is a coroutine.
• 2024‑03‑05: The "missing" graph datatype already exists. It was invented in the 1970s: relational algebra and datalog.
• 2024‑03‑05: Behind F1's velvet curtain.
• 2024‑03‑04: The hunt for the missing graph data type.
• 2024‑03‑04: Migrating from Emacs lsp-mode to Eglot.
• 2024‑03‑04: Motion blur all the way down.
• 2024‑03‑04: Kubernetes failure stories.
• 2024‑03‑03: The case against geometric algebra.
• 2024‑03‑03: 50 years ago: the new Cambridge University Press printing house.
• 2024‑02‑26: Tracing the baseband: cellphone modems.
• 2024‑02‑26: What is the "God Mode" folder in Windows 10, and how do I enable it?
• 2024‑02‑25: Beware of -ffast-math and -Ofast.
• 2024‑02‑24: Really large git repositories.
• 2024‑02‑22: What modern NVMe storage can do, and how to exploit it: high-performance I/O for high-performance storage engines.
• 2024‑02‑22: A security kernel based on the lambda calculus.
• 2024‑02‑18: Ten Python datetime pitfalls, and what libraries are (not) doing about it.
• 2024‑02‑18: Smoothed asymptotics: from number theory to quantum field theory.
• 2024‑02‑14: Thomas Rokicki’s survey of algorithms for Conway’s Game of Life.
• 2024‑02‑13: Conway's Game of Life is omniperiodic.
• 2024‑02‑07: jj init : an introduction to the jujutsu version control system.
• 2024‑02‑06: RCL: A reasonable configuration language.
• 2024‑02‑03: A 3D mouse with 3D printed flexures and PCB coils.
• 2024‑02‑03: Pkl: a programming language for configuration.
• 2024‑01‑31: A homemade telephone exchange for rotary dial phones.
• 2024‑01‑29: __VA_OPT__ minutiae.
• 2024‑01‑29: Recursive macros with C++20 __VA_OPT__.
• 2024‑01‑17: Passing nothing is surprisingly difficult: empty slices in C, C++, and Rust.
• 2024‑01‑15: MULTIPLY: the Francis Hookham collection of hand held electronic calculators.
• 2024‑01‑15: When random isn't.
• 2024‑01‑14: QMK and keyboards.
• 2024‑01‑08: niri: A scrollable-tiling Wayland compositor.
• 2024‑01‑08: How to stop Linux threads cleanly.
• 2024‑01‑06: Vectrex reborn: How a chance encounter gave new life to a dead console.
• 2024‑01‑05: Speed up your code: don't pass structs bigger than 16 bytes on AMD64.
• 2024‑01‑04: Golang: what we got right, what we got wrong.
• 2024‑01‑04: An overview of the Starlark programming language.
• 2024‑01‑03: Spatial Shell: a window layout assistant for i3 and sway.
• 2024‑01‑03: newm-atha: a touchpad and touchscreen centric wayland compositor.
• 2024‑01‑03: SIEVE is simpler than LRU.
• 2024‑01‑02: What I've learned about flow fields for generative art.
• 2024‑01‑02: A CAP tradeoff in Kubernetes.
• 2024‑01‑02: LLM generated code is like particleboard.
• 2023‑12‑31: How I forked SteamOS for my living room PC.
• 2023‑12‑30: Git commit signing is kinda wack.
• 2023‑12‑28: The heart of a language server.
• 2023‑12‑27: How America turned the tide in the cockroach wars.
• 2023‑12‑27: A national evil: how iodized salt banished the curse of the goitre from Switzerland.
• 2023‑12‑26: Fixing the TPM: hardware security modules done right.
• 2023‑12‑26: What is a parser mismatch vulnerability?
• 2023‑12‑26: rscss: a reasonable system for CSS stylesheet structure.
• 2023‑12‑26: Lotus 1-2-3 for Linux.
• 2023‑12‑26: Reptar: an Intel x86 microcode bug.
• 2023‑12‑21: How to find secure hash collisions.
• 2023‑12‑17: Lessons from implementing the Hurl programming language.
• 2023‑12‑16: Why aren't we SIEVE-ing? A new cache eviction algorithm.
• 2023‑12‑15: Forcy McForceFace: building a keyboard switch force tester out of an old 3D printer.
• 2023‑12‑13: Unauthenticated Bluetooth keystroke-injection in Android, Linux, macOS, and iOS.
• 2023‑12‑11: How many lines of C it takes to execute a + b in Python.
• 2023‑12‑11: Compiling to categories.
• 2023‑12‑11: Cutting out continuations.
• 2023‑12‑10: Lambda to SKI, semantically.
• 2023‑12‑08: A brief history of keyboard encoding.
• 2023‑12‑05: A branchless quicksort partition algorithm.
• 2023‑12‑05: Behind the scenes of Rust string formatting and format_args!().
• 2023‑12‑05: That's FAR-out, man: a kernel infoleak in Mac OS xnu.
• 2023‑12‑05: Stop stealing sheep, and find out how typography works.
• 2023‑12‑05: HTML: The Programming Language.
• 2023‑12‑04: Wayland isn't going to save the Linux desktop.
• 2023‑12‑04: You don't need JavaScript for that.
• 2023‑12‑03: fastgron: make JSON greppable, super fast!
• 2023‑12‑03: Monocypher 4: the clean break.
• 2023‑11‑29: Why is Rust slower to read a file than Python?
• 2023‑11‑29: Destructing trees safely and cheaply.
• 2023‑11‑28: It's About Time! Accurate clocks in distributed systems.
• 2023‑11‑27: The largest number representable in 64 bits.
• 2023‑11‑24: FullControl: unconstrained gcode design for 3D printers.
• 2023‑11‑23: Wasmtime and Cranelift in 2023.
• 2023‑11‑23: Commercial flights driven off course by GPS spoofing attacks.
• 2023‑11‑22: Why does the moon change size when you snipe it in GTA?
• 2023‑11‑21: How I (kind of) killed Mercurial at Mozilla.
• 2023‑11‑21: Lessons from METAFONT.
• 2023‑11‑21: Drawing diagrams for TeX with MetaPost.
• 2023‑11‑20: A close encounter with false sharing in Rust.
• 2023‑11‑20: Friends don't let friends make bad graphs.
• 2023‑11‑20: setenv() is not thread safe and C doesn't want to fix it.
• 2023‑11‑19: A simple ray tracer written in the meson.build language.
• 2023‑11‑19: Checking Rust crate semver stability in the presence of doc(hidden) items.
• 2023‑11‑17: Oops! We Automated Bullshit.
• 2023‑11‑17: Why you need a "WTF notebook".
• 2023‑11‑16: Can your static type system handle linear algebra?
• 2023‑11‑16: C++ std::source_location is broken.
• 2023‑11‑16: We don’t do DST at this company.
• 2023‑11‑16: A subtle Python SIGPIPE bug.
• 2023‑11‑15: Popcount walks: next, previous, toward and nearest.
• 2023‑11‑14: Let’s be real about dependencies.
• 2023‑11‑14: Replacing HLS/DASH with Media over QUIC.
• 2023‑11‑13: 37 is the median value for the second prime factor of an integer.
• 2023‑11‑12: A quick look at register allocation with destination-driven code generation.
• 2023‑11‑12: Space Invaders street art mosaics.
• 2023‑11‑09: Interesting JavaScript bugs caught by no-constant-binary-expression in ESLint.
• 2023‑11‑08: Surprising facts about new CSS selectors.
• 2023‑11‑07: Reducing Raspberry Pi 5's power consumption by 140x.
• 2023‑11‑07: Can solar and wind power Britain? An update of David MacKay’s numbers.
• 2023‑11‑07: Jezebel and the question of women’s anger.
• 2023‑11‑05: A proposed fix for C/C++ relaxed atomics in practice.
• 2023‑11‑05: Ungrammar in Go and resilient parsing.
• 2023‑11‑03: Avoiding fallback and cold paths.
• 2023‑10‑26: Technical documentation for Citus distributed PostgreSQL.
• 2023‑10‑23: Y2038: why Steam started picking a random font.
• 2023‑10‑23: Protomaps: an open source map of the world, deployable as a single static file.
• 2023‑10‑21: Electromechanical refreshable Braille module.
• 2023‑10‑21: The not-so-glamourous origins of standard railway track gauge.
• 2023‑10‑21: Analyzing data 180,000x faster with Rust.
• 2023‑10‑20: How to mitigate the Hetzner/Linode XMPP.ru MitM attack.
• 2023‑10‑20: TLS MITM attack against a Russian XMPP / Jabber service.
• 2023‑10‑20: ANSI terminal security in 2023 and finding 10 CVEs.
• 2023‑10‑20: Mandelbrot deep zoom theory and practice.
• 2023‑10‑19: Stop your (business rules) engines!
• 2023‑10‑19: The road to hell is paved with good intentions and C++ modules.
• 2023‑10‑17: Higher quality random floats.
• 2023‑10‑15: Faster compile times from simpler dependency graphs in Rust.
• 2023‑10‑14: Open Props: sub-atomic CSS.