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‑08‑26: One universal antiviral to rule them all?
2025‑08‑20: Code review can be better.
2025‑07‑30: Typechecking is undecidable when 'type' is a type.
2025‑08‑22: The baby paradox in Haskell.
2025‑08‑21: Arch Linux AUR chaos malware: an analysis.
2025‑08‑27: Put a ring on it: a lock-free MPMC ring buffer.
2025‑08‑18: Why I prefer reStructuredText to Markdown.
2025‑08‑29: Blocky planet: making Minecraft spherical.
2025‑08‑26: Emulating aarch64 in software using JIT compilation and Rust.
2025‑08‑25: Nullable vs nullable in C#.
2025‑08‑22: Speed wins when fuzzing Rust code with #[derive(Arbitrary)].
2025‑05‑23: How AI botnet DDoS attacks use compromised end-user devices.
2025‑08‑08: CHICKEN Scheme internals: the garbage collector.
2025‑06‑17: KiCad and Wayland.
2025‑08‑25: Why is cloud file-sharing hard? By analogy with programming misconceptions.
2025‑08‑13: The history of an old joke: “From here?!”
2025‑05‑18: Mystical: a way to write PostScript that looks like a magical circle.
2025‑08‑20: Atmos: a language for structured concurrency and event-driven programming, based on Lua.
2025‑06‑22: tayga: NAT64 for Linux.
2024‑11‑21: Tiling with three polygons is undecidable.
2025‑08‑19: AsciiDots: an esoteric programming language based on ascii art.
2025‑05‑23: The curious case of the “pygmy nuthatch” in Charlie’s Angels.
2025‑08‑19: Without the futex, it's futile.
2025‑07‑23: Web browser tiny monospace fonts workaround.
2025‑08‑21: Sapir-Whorf does not apply to programming languages.
2025‑08‑25: Who's afraid of a hard page load?
2025‑08‑13: Type inference for plain data.
2025‑06‑24: The modern text rendering pipeline: unicode, bidi, segmentation, shaping, …
2025‑08‑19: Shared memory consistency models: a tutorial. (1996)
2025‑07‑30: Mosquito Bucket of Death.
2025‑08‑21: Fun and weirdness with SSDs and PostgreSQL.
2025‑07‑26: Lecture notes on the π-calculus and Concurrent ML.
2025‑08‑06: Minimal version selection revisited.
2025‑04‑30: Swarm testing data structures.
2025‑08‑13: Linear scan register allocation on SSA.
2025‑06‑05: From Krivine’s machine to the Caml implementations.
2025‑07‑27: Implementing a functional language with graph reduction.
2025‑06‑06: Magic namerefs in bash.
2025‑05‑15: 2025 M7.7 earthquake at Mandalay in Burma / Myanmar.
2025‑08‑10: Cracking the Vault: flaws in authentication, identity, and authorization in HashiCorp Vault.
2021‑03‑03: Linux desktop on Apple Silicon M1 in practice.
2025‑08‑19: The Nickel configuration language.
2025‑07‑18: Dissonance: a journey through musical possibility space.
2025‑08‑11: The enduring puzzle of static electricity.
2025‑08‑04: A gentle introduction to liquid types.
2025‑08‑19: CRLite: fast, private, and comprehensive certificate revocation checking in Firefox.
2025‑05‑13: Intransitive operator precedence: we can do better.
2025‑07‑14: Row polymorphic programming.
2025‑07‑03: The tar archive format, its extensions, and why GNU tar extracts in quadratic time.
2025‑06‑06: A tutorial implementation of a dependently typed lambda calculus.
2025‑08‑20: Why some of us like "interdiff" code review.
2025‑08‑07: HTTP/1.1 proxies must die: the desync endgame.
2025‑08‑16: Anaphoric macros introduce hidden bindings in Lisp.
2024‑10‑17: Damas-Hindley-Milner inference two ways.
2025‑08‑16: What next in programming languages?
2025‑05‑21: Game math: precise control over numeric springing.
2025‑08‑16: The future of large files in Git is Git.
2025‑08‑20: Fuss, futexes and furwocks: fast userlevel locking in Linux.
2021‑05‑12: Creating a read-only PostgreSQL user.
2025‑08‑13: Snooping on slow builds using syscalls.
2025‑08‑10: Creating high quality electronics schematics.
2025‑08‑08: Hollerith 1890 census tabulator and the evolution of the IBM punched card.
2025‑08‑18: Basic dependency injection with objects in OCaml.
2025‑08‑17: A programmer's field guide to assertions.
2025‑08‑13: A comparison of C libraries providing generic containers.
2025‑05‑02: What I've learned from jj.
2025‑08‑14: NaN-propagation: a novel method for sparsity detection in black-box computational functions.
2025‑08‑05: A type designer's take on Indian sign painting.
2025‑08‑17: A brief consideration of input shapes for fuzzers.
2025‑05‑15: The centenary of the loudspeaker.
2025‑08‑05: Rod Bustall: in memoriam.
2025‑06‑25: Taming the bicycle, by Mark Twain.
2025‑05‑17: rapidhash: a very fast, high quality, platform-independent hashing algorithm.
2024‑06‑29: Mix-testing: revealing a new class of compiler concurrency bugs.
2025‑07‑08: Announcing FOKS, the Federated Open Key Service.
2025‑06‑11: A survey of source code sandboxing across unix-like systems.
2025‑08‑07: You know more Finnish than you think.
2025‑05‑30: Parsing distfix operators.
2025‑07‑06: Get the location of the ISS using DNS.
2025‑08‑12: A tiny (1000 lines), fastish, embeddable scripting language that can be AOT compiled.
2025‑08‑05: Cordoomceps: replacing an Amiga's brain with a Raspberry Pi running Doom.
2024‑12‑04: Legacy safety: the Wrocław C++ wg21 meeting.
2025‑08‑10: Zig's lovely syntax.
2025‑06‑25: xtool: a cross-platform Xcode replacement.
2025‑02‑07: Updating a large codebase to Rust 2024.
2025‑08‑08: The seven virtues of simple type theory / higher-order logic.
2025‑06‑25: Using LXCFS together with Podman.
2025‑07‑30: Flat design vs rich (“skeuomorphic”) design: a bibliography.
2025‑08‑11: Why Metropolis–Hastings works.
2025‑06‑28: Map projection transitions.
2025‑07‑22: Tony Hoare on record handling. (1965)
2025‑08‑05: Can You Block It ? a simple ad block tester.
2025‑06‑24: Lifetime dispersion and generational GC.
2025‑04‑30: Apple's sillyballs (1988).
2025‑07‑21: The key to understanding “Dynamic Programming” is that it’s not referring to “computer programming”.
2025‑08‑03: rust-parallel: Run commands in parallel and aggregate outputs, like GNU parallel.
2025‑03‑17: A review of the Helix editor after 1.5 years.
2025‑08‑04: Explicit refinement types.
2025‑07‑19: Asynchrony is not concurrency.
2025‑06‑24: Mechanical watch: exploded view.
2025‑08‑03: CriTcl: easily embed C code in Tcl.
2025‑08‑06: A proper x86 assembler in Haskell using the Escardó-Oliva functional.
2025‑03‑24: Cool but obscure X11 tools.
2025‑06‑01: No value restriction is needed for algebraic effects and handlers.
2025‑07‑29: Jujutsu for busy devs.
2025‑07‑30: Programming languages and dimensions of units of measure.
2024‑07‑27: Bril: an intermediate language for teaching compilers.
2025‑06‑05: The impossible predicament of the death newts.
2025‑07‑18: A queer history of computing: Peter Landin.
2025‑08‑01: What declarative languages are.
2025‑04‑17: Graham: synchronizing clocks by measuring server temperature.
2025‑08‑05: My ideal array language.
2025‑07‑30: How attackers are still phishing "phishing-resistant" passkey authentication.
2025‑08‑01: Tracking source locations for profiling GPU programs in Futhark.
2025‑08‑05: AdBlock Tester: test your AdBlock extensions.
2025‑08‑02: Rubik's cube perfect scramble.
2025‑04‑21: Python's new template t-strings.
2025‑02‑15: Post-mortem of network outage affecting OpenStreetMap.org in December 2024.
2025‑07‑18: Replication of quantum factorisation records with an 8-bit home computer, an abacus, and a dog.
2022‑04‑30: Luhn credit card checksum using SWAR and SIMD.
2025‑07‑14: Stepanov’s biggest blunder in the C++ STL.
2025‑05‑10: In praise of grobi for auto-configuring X11 monitors.
2025‑07‑27: MSWasm: soundly enforcing memory-safe execution of unsafe code based on CHERI.
2025‑08‑05: Apache ECharts: a JavaScript data visualization / graphing library.
2025‑07‑26: Slightly better HTML named character reference tokenization for the Ladybird browser.
2025‑07‑08: Find memory errors in unsafe Rust in production with GWP-ASan and the Scudo hardened allocator.
2025‑07‑22: Anatomy of a SYN-ACK attack.
2025‑07‑14: Strategies for very fast lexers.
2025‑07‑27: The Venetian origins of roman type.
2025‑07‑29: Simple and fast derived traits in Rust using rules_derive.
2025‑05‑21: Writing into uninitialized buffers in Rust.
2025‑07‑27: How LLVM optimizes power sums with scalar evolution.
2025‑07‑11: A hole in Ada type safety.
2025‑06‑27: tinyfeed: Generate a static HTML page from a collection of feed URLs.
2025‑07‑26: A new Concurrent ML in Guile Scheme.
2025‑07‑30: Types for units of measure: theory and practice.
2025‑07‑31: The math is haunted: an introduction to Lean.
2025‑04‑15: Algebraic semantics for machine knitting.
2025‑06‑26: Text box drawing combinators.
2025‑07‑31: Golang's race detector has a mutex blind spot.
2025‑07‑14: Binding application in Idris.
2025‑05‑14: The mass-energy-information equivalence principle.
2025‑07‑26: Rust running on every GPU.
2025‑05‑22: Decibels are ridiculous: celebrating a rare dumpster fire in the kingdom of metrology.
2025‑07‑03: Portability of tar features.
2025‑05‑26: A comprehensive list of Wayland compositors.
2025‑08‑01: Making a compiler to prove tmux Is Turing complete.
2025‑07‑19: Current technology is not ready for proper alpha blending.
2025‑05‑06: TinyBits: smaller, faster serialization for Ruby apps and beyond.
2025‑07‑05: The calculator-on-a-chip.
2025‑05‑14: Woodland Trust ancient tree inventory.
2025‑07‑19: The inerter / J-damper: a genius device that rocked Formula 1.
2025‑05‑10: Algebraic effects: another mistake carried through to perfection?
2025‑07‑23: JSON is not a subset of YAML.
2025‑04‑10: Computer science Logo style.
2025‑07‑15: How to avoid out-of-thin-air atomics without really trying.
2024‑05‑09: Development notes from xkcd's "Machine".
2025‑04‑30: My sourdough starter has twins.
2025‑07‑16: Linear-time matching of JavaScript regular expressions.
2025‑07‑23: CSS font-size-adjust is useful.
2025‑07‑30: Poke-a-hole (pahole) and dwarves: examine data structure layouts in DWARF debug info.
2025‑06‑22: Hask is not a category.
2025‑07‑22: Tony Hoare on record handling. (1966)
2025‑07‑18: Losing programming language features: some stories about sum types / disjoint unions / variant records.
2025‑07‑15: Intra-procedural lifetime and borrowing analysis in Clang.
2025‑05‑15: Optimizing with novel calendrical algorithms.
2025‑07‑03: Firefox's optimized zip format: reading zip files really quickly.
2025‑07‑01: Types of types in Lean: common → exotic.
2025‑07‑22: John McCarthy’s 1964 proposal for the definition of product and sum types in ALGOL X.
2025‑06‑18: The web server doesn't render anything.
2021‑02‑19: Cranelift compiler efficiency, CFGs, and a branch peephole optimizer.
2025‑07‑10: eslogger: trace filesystem events using the Mac OS X endpoint security framework.
2025‑02‑28: A survey of every iterator variant in Rust.
2025‑06‑26: Associated vs unassociated alpha channel compositing.
2025‑07‑24: Parsing protobuf like never before.
2025‑06‑22: Compact representations for arrays in Lua.
2025‑07‑16: Lower your guards: a compositional pattern-match coverage checker.
2025‑07‑23: The Par programming language.
2024‑09‑27: Hacking Kia: remotely controlling cars with just a license plate.
2025‑02‑13: libu8ident: Unicode security guidelines for programming language identifiers.
2023‑01‑08: There is no software maintenance.
2025‑06‑24: The one-more-re-nightmare regex engine for Common Lisp.
2023‑11‑24: The story of titanium.
2021‑03‑27: ohm: a JavaScript library and PEG-based language for building parsers.
2025‑07‑01: Fun with git: updating the cached contents in the index by staging.
2025‑07‑23: BBC3 The Wrong Door — The Train Pirates.
2025‑07‑06: Developing a transputer ISA board.
2025‑06‑08: The story of ispc: Intel implicit SPMD single program multiple data compiler.
2025‑06‑13: Rendering crispy text on the GPU.
2025‑06‑22: How fast are Linux pipes anyway?
2025‑05‑21: The NSA selector eurorack module.
2025‑07‑11: They write the right stuff: software engineering for the Space Shuttle.
2025‑04‑11: Walking the London Loop.
2025‑06‑30: The provenance memory model for C.
2025‑07‑19: Avoiding COVID with carrageenan nasal spray.
2025‑06‑23: How to open a file in Emacs.
2025‑01‑07: Servo revival 2023-2024.
2025‑07‑15: A lightweight TCP in UDP tunnel using eBPF for MPTCP.
2025‑07‑17: The (unfinished) partial differential equation coffee table book.
2025‑07‑16: GPUHammer: rowhammer attacks on GPU memories are practical.
2025‑03‑22: μFork: a pure actor-based concurrent machine architecture with memory-safety and object-capability security.
2025‑07‑12: CSS performance: Don't animate height!
2025‑07‑15: Designing for the eye: optical corrections in architecture and typography.
2025‑02‑11: A catalog of ways that compilers generate SSA.
2023‑04‑27: Bringing runtime index checks to compile time in Rust.
2025‑05‑10: Kernighan's lever.
2025‑07‑10: Optimizing a simple expression parser in Rust.
2025‑01‑03: Remote reboots with encrypted disks on Arch Linux.
2025‑06‑06: yeri: JavaScript library for graphing timeseries data into an SVG.
2025‑04‑17: RE#: high performance derivative-based regex matching with intersection, complement, and lookarounds.
2024‑12‑17: Golang's weird little iterators.
2025‑07‑02: Chess grandmasters do not burn 6000 calories per day.
2025‑05‑27: Square theory and unparalleled misalignments in American-style crosswords.
2025‑03‑26: Succinct data structures.
2025‑07‑15: Adding lookbehinds to Rust’s regex crate.
2025‑07‑18: Dana Scott on the lambda calculus, then and now.
2025‑06‑11: Modern minimal perfect hashing: a survey.
2025‑06‑27: Structuring arrays with algebraic shapes.
2025‑07‑10: PostgreSQL LISTEN/NOTIFY does not scale.
2025‑02‑28: Historic tale construction kit: make your own Bayeux tapestry.
2025‑04‑04: Some pitfalls of safe Rust.
2025‑02‑13: Building a hyper-personalized seach engine that isn't very good.
2025‑07‑11: Faking a JPEG to feed to an abusive web crawler.
2025‑06‑05: Unix, Plan 9, and the lurking SmallTalk.
2023‑06‑22: An epicyclic clock.
2021‑03‑20: The design of forms in government departments.
2025‑01‑22: Guided by the beauty of our test suite: snapchot texting, fuzz testing, and panic freedom in Rust.
2025‑06‑24: Forbidden secrets of ancient X11 scaling technology revealed!
2025‑06‑22: Nearley.js: a toolkit for parsers written in JavaScript.
2025‑05‑31: Dynamic witnesses for static type errors in OCaml, or, ill-typed programs usually go wrong.
2025‑04‑14: Unlocking sudoku's secrets with graph theory and abstract algebra.
2025‑04‑12: Molecules with silly or unusual names.
2025‑04‑30: NIST F4 caesium fountain atomic cock joins elite group that keeps the world on time.
2025‑04‑23: Exploiting undefined behavior in C/C++ programs for optimization: a study on the performance impact.
2025‑05‑16: Rustls server-side performance.
2025‑06‑24: Bazel’s original sins.
2025‑06‑18: fx: view and process JSON with JavaScript on the command line.
2025‑07‑06: Speed up Magit on MacOS by using git from Homebrew.
2025‑07‑08: PostgreSQL replication slots: preventing WAL bloat and other production issues.
2025‑07‑12: A new Finnish flavor of feline coat coloration, “salmiak”.
2025‑01‑10: Soldering the Tektronix way.
2025‑01‑14: Phil Rogaway on radical computer science.
2025‑04‑15: Getting started with the W65C832 FPGA core, a 32 bit extended 6502.
2024‑05‑06: Re-implementing the Nix protocol in Rust.
2022‑11‑09: Rain of Fire Falling: The crash of American Airlines flight 191.
2025‑07‑08: svg-term-cli: animated terminal sessions using SVG and CSS.
2024‑11‑23: gofumpt: a stricter gofmt.
2022‑12‑26: Performance of memory reclamation for lockless synchronization.
2025‑01‑10: SIMD in Rust: you do not need multithreading to do more than one thing at a time.
2025‑06‑25: Reading NFC passport chips in Linux.
2025‑06‑06: Sharing everything I could understand about gradient noise / Perlin noise.
2025‑05‑29: Bootstrapping HTTP/1.1, HTTP/2, and HTTP/3.
2025‑06‑01: The Story of Mel, annotated.
2025‑05‑26: Client rate throttling in the Heroku platform API Ruby gem.
2025‑06‑11: Idris 2: quantitative type theory in practice.
2025‑06‑18: Type inference zoo.
2025‑04‑12: Weird architectures weren't supported to begin with.
2025‑07‑08: Emacs which-key vs Embark for help on prefix keymaps.
2025‑05‑30: Parsing mixfix operators.
2021‑03‑19: A Mind Is Born: 256 byte Commodore 64 demo.
2025‑04‑15: What the hell Is a target triple?
2025‑06‑16: Critical analysis of the Meshtastic protocol.
2025‑07‑05: The ITTAGE indirect branch predictor.
2025‑05‑06: What is my fuzzer doing? How to get coverage of Rust code.
2025‑07‑08: SIMD.info: searchable reference for C intrinsics.
2025‑06‑05: Picking uncontested private IP subnets with usage data.
2025‑06‑18: The plight of the misunderstood atomic memory ordering.
2025‑05‑31: Mel's Loop: a comprehensive guide to The Story of Mel.
2025‑02‑05: Mach-O linking and loading tricks.
2025‑05‑14: ZJIT has been merged into Ruby.
2025‑06‑17: Nasal sprays for covid prophylaxis.
2024‑05‑28: Statistical shortcomings in standard math libraries, and how to fix them.
2021‑06‑17: Exploring ways to make async Rust easier.
2025‑05‑29: Making openat(2) and friends more useful in OpenBSD.
2025‑02‑15: Taichi: high-performance parallel programming in Python.
2025‑06‑14: Lambda calculus cooked N ways: Benchmarks for capture-avoiding substitution.
2025‑06‑04: AMEN: Church numeral addition, multiplication, exponentiation, and nothing are a complete combinator basis.
2025‑06‑08: Making sense of atomic acquire-release semantics.
2025‑05‑29: Programming = proving? The Curry-Howard correspondence today.
2025‑06‑02: Eﬃcient manipulation of binary data using pattern matching.
2025‑05‑17: Structured combinators for efficient graph reduction.
2025‑06‑19: The missing 11th of the month.
2025‑03‑31: A brief history of Erlang’s BEAM compiler.
2025‑05‑18: Fortran for C programmers.
2025‑06‑05: Vectorized interpreters: mass rapid transit for programming languages.
2025‑06‑30: Building accurate postal address matching systems.
2024‑07‑05: I Have No Constructor, and I Must Initialize.
2025‑06‑25: A new 3rd edition PNG spec was just released!
2025‑05‑27: Using otel to emit and view debug traces from Golang command-line tools.
2025‑05‑07: Tantacrul on Finale: how music software dies. (video)
2025‑06‑30: Booleans are a trap.
2024‑11‑25: The SLAX scripting language: an alternative syntax for XSLT.
2025‑06‑06: Recovering control flow structures from Java bytecode without CFGs.
2025‑06‑24: Programming parallel computers.
2025‑07‑01: Parsing layout, or: Haskell's syntax is a mess.
2025‑06‑16: Roadmap towards the redefinition of the second.
2025‑06‑30: That boolean should probably be something else.
2025‑05‑27: BGP handling bug causes widespread internet routing instability.
2024‑10‑22: Use test data that looks like data.
2025‑06‑02: When do pattern match compilation heuristics matter?
2025‑06‑03: Where did C++ <random> go wrong?
2025‑05‑27: Relocation generation in assemblers.
2025‑05‑02: POSIX shell and utilities quick reference.
2025‑03‑25: The Prospero challenge.
2025‑06‑03: From Prometheus to RRDtool graphs.
2025‑05‑16: I don't like NumPy.
2021‑11‑12: Three cases against IF NOT EXISTS / IF EXISTS in PostgreSQL DDL.
2025‑06‑06: How common is multiple invention?
2025‑06‑17: The saga of phkmalloc.
2025‑04‑08: netbird: Connect your devices into a WireGuard overlay network with SSO, MFA and granular access controls.
2025‑03‑30: Let's create a Tree-sitter grammar.
2025‑06‑19: Elliptic curves as art.
2024‑12‑17: UK Online Safety Act Notes for small sites.
2025‑05‑20: A Python frozenset interpretation of dependent type theory.
2024‑07‑25: strlcpy and how CPUs can defy common sense.
2025‑06‑07: cdimage: A tool for burning visible pictures on a compact disc.
2025‑05‑13: Writing that can change how you think about programming languages.
2025‑06‑22: Basic facts about GPUs.
2025‑05‑26: Ironies of automation. (1983)
2025‑05‑14: The database row that did and didn't exist according to Django.
2025‑01‑25: Why the north of England is poor.
2025‑06‑05: The IELR(1) algorithm for generating minimal LR(1) parser tables for non-LR(1) grammars with conflict resolution.
2025‑06‑12: The Epic Verse calculus: a core calculus for functional logic programming.
2025‑05‑26: Against Curry-Howard mysticism.
2025‑06‑23: Making emacs tramp go brrrr.
2024‑11‑06: The Manchester Compiler Compiler and CPL: reflections of a user 50 years on.
2025‑01‑13: Why is my Chumby’s CPU usage always 100%?
2025‑04‑13: 10 years of pomological watercolors.
2021‑02‑18: ECFiber: building a fibre-to-the-premises network in rural Vermont.
2024‑08‑11: Trolltech's Qt documentation process.
2025‑04‑25: Bluefishjs: composing diagrams in with declarative relations.
2025‑05‑16: Heron: modern hardware graph reduction.
2025‑03‑18: Portable dynamically linked packages on Linux.
2025‑04‑09: I Got Plenty o’ Nuttin’: linear dependent types.
2025‑06‑18: A collection of articles about retries.
2025‑02‑16: Arithmetic with continued fractions.
2025‑06‑23: BNFGen: a random text generator based on context-free grammars
2025‑05‑21: Staged compilation with two-level type theory.
2025‑04‑30: autosetup: a Tcl-based build environment "autoconfigurator".
2025‑02‑14: Homemade polarimetric synthetic aperture radar drone.
2025‑03‑22: HAFLANG: hardware acceleration of functional languages.
2025‑04‑25: Bluefishjs: a diagram drawing framework for JavaScript.
2025‑03‑29: A language server protocol (LSP) implementation for PostgreSQL.
2025‑01‑05: Reliable system call interception with Linux seccomp.
2023‑08‑04: The joys of UNIX keyboards.
2024‑12‑13: Thoughts on hashing in Rust.
2025‑06‑12: A multivalued language with a dependent type system. (A precursor to Epic Verse.)
2025‑03‑30: Towards fearless SIMD in Rust, 7 years later.
2025‑01‑28: A retrospective on SCCS, the Source Code Control System.
2025‑04‑12: Why is there a "small house" in IBM's code page 437?
2025‑05‑22: Blazingly fast™ type class resolution with a trie.
2025‑05‑15: Fixing the traffic jam in the science of technology safety.
2025‑06‑10: Dependent types and program equivalence.
2025‑02‑08: Fend: an arbitrary-precision unit-aware calculator.
2025‑06‑03: What's higher-order about so-called higher-order references?
2025‑05‑02: Optimizing programs written in Guile Scheme.
2025‑03‑24: faer: a general-purpose linear algebra library for Rust.
2024‑12‑26: Rewriting the Ruby parser.
2025‑05‑21: Dependent types at work in Agda.
2025‑04‑08: On the complexity and performance of parsing with derivatives.
2025‑03‑21: I want a good parallel computer.
2025‑05‑15: A Rust API inspired by Python, powered by Serde.
2025‑06‑08: Simulating time with square-root space.
2023‑05‑07: Deploying IPv6-mostly access networks.
2024‑09‑21: Boolean blindness.
2025‑04‑12: awe: A compiler for the Algol W programming language.
2025‑04‑01: Electron band structure in germanium, my ass.
2025‑06‑18: Posit floating point numbers: thin triangles and other tricks.
2025‑01‑11: Jef Raskin: Intuitive equals familiar. (1994)
2025‑02‑27: Efficient communication and collection with compact normal forms in Haskell.
2025‑06‑02: Pattern matching and exhaustiveness checking algorithms implemented in Rust.
2025‑03‑14: HashChain: a family of very fast factor-based sublinear exact-matching string search algorithms.
2024‑10‑08: Eidophor: 1950's space age video projection technology. (video)
2025‑05‑26: Microsoft Windows Registry attack surface analysis.
2025‑03‑13: Triangle of power notation: exponents roots and logarithms.
2025‑05‑31: Toxic Origins, Toxic Decisions: bias in CEO selection towards risk-taking, analysed using polluted Superfund sites.
2025‑04‑11: Situated software.
2025‑06‑05: IELR(1): practical LR(1) parser tables for non-LR(1) grammars with conflict resolution.
2025‑03‑07: JA4+: a suite of network fingerprinting standards.
2025‑05‑09: Static interpretation of higher-order modules in Futhark: functional GPU programming in the large.
2025‑04‑25: Logarithms of algebraic data types for property-based testing.
2024‑09‑22: The sorry state of Java deserialization.
2025‑06‑06: Implementing dependent types in pi-forall.
2025‑06‑13: jemalloc postmortem.
2025‑04‑23: What is cosh(List(Bool))? Or beyond algebra: analysis of data types.
2025‑05‑05: Helmdar: 3D scanning Brooklyn on rollerblades.
2025‑02‑11: Elementary functions NOT following the IEEE 754 floating-point standard.
2025‑04‑11: London Cycle Orbital: peaceful cycling at London's margins.
2025‑01‑25: The invalid 68030 instruction that accidentally allowed the Mac Classic II to successfully boot up.
2025‑05‑16: Lock-free Rust: how to build a rollercoaster while it’s on fire.
2024‑10‑10: What is systems programming, really?
2021‑06‑22: Exploit a binary with sigreturn oriented programming (SROP).
2025‑05‑15: Diagnosing a double-free concurrency bug in Rust's unbounded channels.
2025‑04‑23: PiDP-11 and other replicas of old computers.
2021‑08‑29: Postgres extensions in Rust.
2025‑04‑04: The crisis of zombie social science.
2025‑03‑21: MySQL transactions per second vs fsyncs per second.
2025‑05‑17: CHERIoT: the last ten years.
2025‑05‑16: Initialization in C++ is seriously bonkers.
2025‑03‑23: gif320: A GIF viewer for DEC VT320 terminals.
2025‑04‑14: Clowns to the left of me, jokers to the right: dissecting and dividing algebraic data structures.
2025‑06‑04: Distance-based ISA for efficient register renaming.
2024‑10‑12: Exploring Typst, a new typesetting system similar to LaTeX.
2025‑06‑01: Tools built on tree-sitter's concrete syntax trees.
2025‑06‑08: Weaponizing dependabot: confused deputy pwn request at its finest.
2025‑01‑16: ai.robots.txt: A list of AI agents and robots to block.
2025‑04‑11: The yaml document from hell.
2024‑10‑12: Ki: wireless power for kitchen appliances. (video)
2025‑05‑16: Reservoir sampling: who discovered Algorithm R?
2024‑10‑28: EBCDIC is incompatible with GDPR.
2024‑11‑10: Histogramming bytes with positional popcount, GF2P8AFFINEQB edition.
2025‑06‑03: How to take the inverse of a type.
2025‑05‑18: PostgreSQL lock conflicts quick reference.
2025‑05‑25: Bidirectional typing.
2025‑05‑15: A leap year check in three instructions.
2025‑05‑11: Alan Kay did not invent object-oriented programming.
2025‑04‑29: Syntactic musings on match expressions in Rust.
2025‑06‑06: Hokusai Moyo Gafu: an album of dyeing patterns.
2025‑06‑03: Zero-cost 'tagless initial' in Rust with GADT-style enums.
2025‑05‑31: Precision Clock Mk IV.
2025‑03‑13: Nanowar Of Steel - HelloWorld.java
2024‑11‑02: The ATS programming language: unleashing the potential of types and templates!
2023‑11‑19: A simple ray tracer written in the meson.build language.
2025‑06‑04: DejaGNU (2011)
2025‑02‑13: On Jujutsu and Magit.
2024‑05‑28: aa-56: an astronomical ephemeris calculator program.
2025‑05‑23: That fractal that's been up on my wall for 12 years.
2025‑05‑01: roons: modular marble logic.
2025‑05‑22: Designing APIs for humans: Stripe object IDs.
2025‑04‑27: Silent bugs matter: a study of compiler-introduced security bugs.
2025‑03‑28: Wasm SpecTec has been adopted.
2025‑05‑30: Implementation of dependent types.
2025‑04‑11: Why do AI company logos look like arseholes?
2025‑03‑15: Displaying Korean text efficiently.
2021‑05‑23: Faster remainder by multiplication, with applications to compilers and software libraries.
2025‑05‑17: Don’t use ISO/IEC 14977 Extended Backus-Naur Form (EBNF).
2025‑04‑06: When should a Java JIT compiler expand garbage collection barriers?
2025‑05‑15: Crossness pumping station: seduced by symmetry.
2025‑03‑22: SKIM: The implementation of functional languages using custom hardware.
2025‑05‑12: De Bruijn's combinatorics.
2025‑04‑13: Dijkstra on mathematical notation.
2025‑04‑02: Gerrit, GitButler, and Jujutsu projects collaborating on a change-id commit footer.
2024‑12‑15: Prequal: Load is not what you should balance.
2025‑05‑17: MicroHs: Haskell implemented with combinators by Lennart Augustsson.
2025‑02‑22: How to write mathematics. (1973)
2025‑05‑31: Beating the kCTF PoW with AVX512IFMA for $51k.
2023‑10‑05: Surety: The world’s oldest blockchain has been hiding in the New York Times since 1995.
2025‑02‑27: But can DOOM run it? Programming satan’s computer.
2025‑05‑15: 10 years of stable Rust: an infrastructure story.
2025‑05‑14: The first year of free-threaded Python.
2025‑01‑16: Is Wasm Memory64 actually worth using?
2023‑12‑05: Behind the scenes of Rust string formatting and format_args!().
2024‑04‑25: Why does Windows use backslash as its path separator?
2025‑05‑24: There is no Diffie-Hellman but elliptic curve Diffie-Hellman.
2025‑05‑08: Implement your programming language twice.
2025‑04‑18: Dissolving the Fermi paradox.
2025‑05‑21: The magic of software; or, what makes a good engineer also makes a good engineering organization.
2025‑05‑06: A formulae-as-type notion of control: classical logic and call/cc in Scheme.
2025‑05‑22: Gradients are the new intervals for signed distance function evaluation.
2025‑05‑22: Violating memory safety with Haskell's value restriction.
2025‑05‑26: Type-level bounded recursion in Rust.
2025‑05‑17: O2 VoLTE: locating any customer with a phone call.
2025‑03‑31: comrak: a CommonMark and GFM compatible Markdown parser and renderer in Rust.
2025‑05‑05: On the design of compact elastic binary trees (cebtree).
2024‑04‑09: How I tripped over the Debian weak keys vulnerability.
2023‑07‑17: Why specs matter.
2025‑05‑29: ΠΣ: dependent types without the sugar.
2023‑09‑19: build123d: A Python CAD programming library.
2025‑01‑10: Bad Apple but it's 6,500 regexes that I search for in vim.
2025‑05‑05: Archers did not volley fire.
2024‑12‑20: “Twelfth Night Till Candlemas: the story of a forty-year book-quest and of its remarkable ending.
2025‑03‑31: LALRPOP: a parser generator for Rust.
2024‑10‑20: Jujutsu (jj), a git compatible version control system.
2025‑04‑06: How to sync anything.
2025‑04‑18: Sneak peek: A new ASN.1 API for Python.
2025‑02‑02: Parametric subtyping for structural parametric polymorphism.
2025‑04‑27: DIY book lamp: simple electronics meets paper craft.
2024‑08‑15: A non-uniform quasirandom number generator for games.
2025‑03‑11: Backyard cyanide from the cherry laurel.
2025‑04‑29: Let's Debug figures out why you can’t issue a certificate with Let's Encrypt.
2025‑04‑18: Squiggle: a simple programming language for intuitive probabilistic estimation.
2023‑08‑23: XTerm control sequences.
2025‑04‑09: facet: type reflection, serialization, deserialization — know the shape of your types in Rust.
2025‑03‑12: Representing type lattices compactly.
2025‑04‑18: Decomposing transactional systems.
2025‑03‑28: Specifying Wasm with SpecTec.
2025‑05‑22: Fast allocations in Ruby 3.5.
2025‑05‑14: Preventing outages with pkill's new --require-handler flag.
2025‑03‑11: Far-UVC: germicidal ultraviolet light can inactivate a wide range of pathogens with minimal effects on human tissues.
2025‑01‑30: Scaling the Let’s Encrypt rate limits to prepare for a billion active TLS certificates.
2025‑05‑12: Load-store conflicts.
2024‑07‑26: Why does the chromaticity diagram look like that?
2024‑08‑28: Examples of MVC for the Web.
2025‑05‑06: A continuation-passing evaluation semantics for classical proofs.
2025‑02‑20: TRAVERTINE: CVE-2025-24118 safe memory reclamation race in the XNU Mac OS kernel.
2025‑02‑25: How core git developers configure git.
2025‑04‑26: Venera 8 Kosmos 482 descent craft reentry forecasts.
2025‑05‑19: Modular type classes.
2021‑06‑12: PubSub and RPC with dynamic types in Rust.
2025‑05‑17: Japan's IC cards are weird and wonderful.
2025‑04‑26: Visibly pushdown languages: between regular and context-free.
2024‑08‑04: Programming mantras are proverbs.
2024‑05‑17: Existential types in Rust.
2025‑05‑10: Castle Kellmore 2.5D rendering on the PlayDate handheld game console.
2023‑01‑21: RP2040 DMA is Turing complete.
2025‑02‑14: TeX and Typst layout models.
2025‑05‑02: Elm property-based test case distributions.
2025‑05‑22: Violating memory safety with Haskell's value restriction.
2025‑05‑16: From Haskell to a new structured combinator processor for graph reduction in hardware.
2025‑03‑26: Pi Pico Rx: a crystal radio for the digital age?
2025‑05‑16: Pallene: a statically typed ahead-of-time compiled sister language to Lua, with a focus on performance.
2024‑11‑24: Mark–Scavenge garbage collection: waiting for the trash to take itself out.
2025‑03‑30: Learn CSS layout the pedantic way.
2025‑02‑28: It's the latency, stupid!
2024‑11‑24: Anatomy of a thunk leak in Haskell.
2025‑05‑15: How did REST come to mean the opposite of REST?
2021‑03‑19: A bestiary of mathematical functions for systems designers.
2025‑05‑17: The programming language that never was.
2025‑01‑25: Proper decoupling practices, and why you should leave 100nF behind.
2021‑02‑14: Julia 1.6: what has changed since Julia 1.0?
2025‑03‑25: On the ignorability of attributes in C++.
2025‑04‑15: Two years of Rust.
2024‑09‑01: Raspberry Pi boot optimization: 3.5 sec to Linux userspace code.
2025‑05‑16: Cloaca: a concurrent hardware garbage collector for non-strict functional languages.
2025‑04‑16: Atomicless concurrency.
2025‑04‑30: A collection of quotes on the design of notation as a tool of thought.
2025‑05‑17: Programming in Martin-Lof's type theory: an introduction. (1990)
2025‑03‑05: Encoding Hangeul, Koreas writing system.
2025‑02‑11: Optimal bounds for open addressed hash tables without reordering.
2024‑12‑04: SQL OFFSET is worse than keyset pagination.
2025‑03‑09: Efficient communication and garbage collection in Haskell with compact normal forms.
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.