HTTP/1.1 200 ok Date: Wed, 14 Jan 2026 09:42:10 GMT Server: Apache/2.4.65 (Debian) OpenSSL/1.1.1w mod_perl/2.0.11 Perl/v5.32.1 X-Clacks-Overhead: GNU Terry Pratchett Vary: Accept-Encoding Content-Encoding: gzip Transfer-Encoding: chunked Content-Type: text/html

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 2026 latest

---

• 2026‑01‑13: Stoat: an open-source, user-first chat platform.
• 2026‑01‑12: The J incunabulum.
• 2026‑01‑12: A sign-off review checklist for PCB designs.
• 2026‑01‑11: The Julian Period and Modified Julian Dates.
• 2026‑01‑11: A unique performance optimization for a 3D geometry language.
• 2026‑01‑10: Finding and fixing Ghostty's largest memory leak.
• 2026‑01‑10: Pulling a new proof from Knuth’s fixed-point printer, with code in Ivy.
• 2026‑01‑10: Testing ECC NMI in a cubesat boot loader: intentional flash corruption for STM32 microcontrollers.
• 2026‑01‑10: How Markdown took over the world.
• 2026‑01‑09: An adequate left-associated binary numeral system in the lambda calculus.
• 2026‑01‑08: How to write like a person.
• 2026‑01‑08: Lessons from merging hash tables.
• 2026‑01‑08: Clang hardening cheat sheet, ten years later.
• 2026‑01‑08: How did TVs get so cheap?
• 2026‑01‑08: BLAKE2s hashing accelerator: a solo tapeout journey.
• 2026‑01‑07: Why the trans flag emoji uses a sequence of 5 unicode codepoints.
• 2026‑01‑06: Internet anagram server.
• 2026‑01‑06: Several anti-phonetic alphabets.
• 2026‑01‑06: I/O is no longer the bottleneck? (compared to AVX2 vectorized wc)
• 2026‑01‑06: Marcin Wichary’s favourite tech museums.
• 2026‑01‑05: Who owns the memory? Who calls free?
• 2026‑01‑05: Who owns the memory? How big is your type?
• 2026‑01‑05: Who owns the wemory? What is an Object?
• 2026‑01‑05: Raspberry Pi Reliability: how to reduce writes to your SD card.
• 2026‑01‑05: Using eBPF to load-balance traffic across UDP sockets with Golang.
• 2026‑01‑05: Stop forwarding errors in Rust, start designing them.
• 2026‑01‑04: What is a PC compatible?
• 2026‑01‑04: Four ways to improve a perfect SQL join algorithm.
• 2026‑01‑04: What we’re talking about, when we talk about data destruction.
• 2026‑01‑04: USB-C to 3.5mm headphone audio dongles, a new (but also old) problem.
• 2026‑01‑04: The late arrival of 16-bit CP/M.
• 2026‑01‑04: Hash functions for GPU rendering.
• 2026‑01‑04: Quick and easy GPU random numbers.
• 2026‑01‑04: 3D printed origami.
• 2026‑01‑03: Partial evaluation and automatic program generation. (book, 1993)
• 2026‑01‑02: A survey of dynamic array structures.
• 2026‑01‑02: wpex: WireGuard packet relay for NAT traversal.
• 2026‑01‑02: OpenAlex: The open catalog to the global research system.
• 2026‑01‑01: Sorting with fibonacci numbers, and a Knuth reward check.
• 2026‑01‑01: Eliminate branches by melding IR instructions.
• 2025‑12‑31: Inline PGP signatures considered harmful. (2014)
• 2025‑12‑31: Who invented the transistor?
• 2025‑12‑31: A comptime calculus for Zig.
• 2025‑12‑30: An Ed25519 vulnerability in libsodium.
• 2025‑12‑30: Going down the rabbit hole of git clone --bundle-uri.
• 2025‑12‑30: 1ML for non-specialists.
• 2025‑12‑29: More on shuffles.
• 2025‑12‑28: easrng/schema: derive JSON schema from TypeScript type using LSP autocomplete.
• 2025‑12‑28: Arcan as operating system design.
• 2025‑12‑26: Serde's zero-copy borrowing can be treacherous.
• 2025‑12‑24: The physics of dissonance and harmony.
• 2025‑12‑23: An initial analysis of the rediscovered Unix V4 tape.
• 2025‑12‑23: Managing encrypted filesystems with dirlock.
• 2025‑12‑23: Instant database clones with PostgreSQL 18.
• 2025‑12‑23: dirlock: manage encrypted directories using the Linux kernel's fscrypt API.
• 2025‑12‑21: Running the “Reflections on Trusting Trust” compiler.
• 2025‑12‑21: ARIN incident report: IP address issuance error.
• 2025‑12‑21: Faster practical modular inversion.
• 2025‑12‑18: pg_textsearch: PostgreSQL extension for BM25 relevance-ranked full-text search.
• 2025‑12‑18: MuseAir: A portable hashing algorithm that heavily optimized for performance and quality, incorporating structures never before implemented.
• 2025‑12‑18: Resizable arrays in optimal time and space.
• 2025‑12‑17: Attempting cross translation unit taint analysis for Firefox.
• 2025‑12‑16: Optimization countermeasures: inline asm value barriers for constant-time cryptography.
• 2025‑12‑16: Fix HDMI-CEC weirdness with a Raspberry Pi and a $7 cable.
• 2025‑12‑14: Indexed reverse polish notation, an alternative to AST.
• 2025‑12‑14: Zmij: faster floating point double-to-string conversion.
• 2025‑12‑13: An array index points between elements.
• 2025‑12‑13: Parametric BBC TV clock.
• 2025‑12‑12: Can I use HTTPS RRs?
• 2025‑12‑12: Making lightning in a bottle with a particle accelerator.
• 2025‑12‑12: bidicalc ⇆ a spreadsheet where formulas also update backwards.
• 2025‑12‑12: capsudo: Rethinking sudo with object capabilities.
• 2025‑12‑12: Notes on gamma correction.
• 2025‑12‑12: A Lisp interpreter implemented in Conway’s Game of Life.
• 2025‑12‑11: How Google Maps quietly allocates survival across London’s restaurants, and how I built a dashboard to see through it.
• 2025‑12‑11: The story of Propolice stack overflow protection in OpenBSD.
• 2025‑12‑11: An orbital house of cards: frequent satellite megaconstellation close conjunctions.
• 2025‑12‑10: Stephen Hawking’s floppy disks: an interview with Leontien Talboom.
• 2025‑12‑09: My favourite small hash table: Robin Hood open-addressing with linear probing and power-of-two table size.
• 2025‑12‑09: Peer-reviewed preprints and the Publish-Review-Curate model.
• 2025‑12‑08: The birth of the internet troll.
• 2025‑12‑08: Readable code is unreadable: Arthur Whitney’s J incunabulum.
• 2025‑12‑08: SGML syntax reference.
• 2025‑12‑08: Icons in menus everywhere! Send help!
• 2025‑12‑08: Publish, Review, Curate to upend scholarly publishing.
• 2025‑12‑08: Desperately seeking squircles.
• 2025‑12‑08: Einstein: NewtonOS running on other operating systems.
• 2025‑12‑07: The main features of Atlas Autocode.
• 2025‑12‑07: The IMP programming language and compiler.
• 2025‑12‑07: The significance of Brooker's autocodes in taking the early Manchester machines into the market.
• 2025‑12‑06: Should CSS be a constraint system instead?
• 2025‑12‑06: Front-panel booting an ATmega88 microcontroller.
• 2025‑12‑05: A pixel is not a little square. (1995)
• 2025‑12‑05: Typewriter pen plotters.
• 2025‑12‑05: Super-flat ASTs: data-oriented design for parsers.
• 2025‑12‑04: Why ed(1)?
• 2025‑12‑04: foreign-dlopen: load dynamic libraries into a statically-linked executable.
• 2025‑12‑03: Make invalid laziness unrepresentable in Haskell.
• 2025‑12‑03: It's not always icache: performance of inline functions.
• 2025‑12‑03: Constructing a JPEG XL MD5 hash quine.
• 2025‑12‑03: A distributed systems reliability glossary.
• 2025‑12‑03: Mutation testing for librsvg with cargo-mutants.
• 2025‑12‑02: Lazier binary decision diagrams (BDDs) for set-theoretic types.
• 2025‑12‑02: In defense of lock poisoning in Rust.
• 2025‑12‑02: The triumph of logical English.
• 2025‑12‑02: IPPROTO_ICMP sockets for unprivileged ping on Linux.
• 2025‑12‑02: Rocq: The world’s best macro assembler?
• 2025‑12‑01: Who invented vector clocks?
• 2025‑12‑01: Compressing callstacks: a bitpacked DAG powered by a keyless hashmap.
• 2025‑12‑01: One jobserver to rule them all: controlling parallelism across many concurrent builds.
• 2025‑11‑30: Saving Skylab.
• 2025‑11‑30: Setting a wallpaper in less than 250 Kb: A practical guide to reducing Rust's runtime RAM usage.
• 2025‑11‑30: Datacenters in space are a terrible, horrible, no good idea.
• 2025‑11‑30: Landlock-ing programs on Linux.
• 2025‑11‑29: Schubfach: The smallest state-of-the-art floating point double-to-string implementation.
• 2025‑11‑29: The concrete pontoons of Bristol.
• 2025‑11‑29: A brief history of NSA backdoors. (2013)
• 2025‑11‑28: Putting rigid bodies to rest: analysis and design of resting configurations of rolling dice, without physical simulation.
• 2025‑11‑27: Lazy linearity for a core functional language.
• 2025‑11‑26: Swift regrets: a programming language design retrospective.
• 2025‑11‑26: A very fast 64–bit algorithm to convert day numbers to broken-down dates.
• 2025‑11‑26: Ferrari’s Formula One pit-stops and handovers from surgery to intensive care.
• 2025‑11‑26: Solving the Partridge square packing problem using MiniZinc.
• 2025‑11‑26: XFT (cross fault tolerance) and XPaxos: practical fault tolerance beyond crashes.
• 2025‑11‑25: Naming the Net: The Domain Name System, 1983-1990.
• 2025‑11‑25: Shaders: how to draw high fidelity graphics when all you have is an x and y coordinate.
• 2025‑11‑25: Constant-time support lands in LLVM: Protecting cryptographic code at the compiler level.
• 2025‑11‑25: The Penicillin myth.
• 2025‑11‑25: The essence of LR parsing: Partial evaluation can turn a general parser into a parser generator.
• 2025‑11‑25: Implementing dependent types: how hard could it be? (Part 2)
• 2025‑11‑25: Implementing dependent types: how hard could it be? (Part 1)
• 2025‑11‑24: Counter Galois Onion: Improved encryption for Tor circuit traffic.
• 2025‑11‑23: Nonpareil: high-fidelity HP calculator simulator.
• 2025‑11‑23: libfive: solid modelling with functional representations.
• 2025‑11‑23: Parallel threads in Racket v9.0.
• 2025‑11‑23: The uncertain origins of Aspirin.
• 2025‑11‑23: What now? Handling errors in large systems.
• 2025‑11‑23: USB in a nutshell: making sense of the USB standard.
• 2025‑11‑22: WiFi positioning system: how my laptop knows where I am.
• 2025‑11‑21: Reverse engineering the Miele diagnostic interface.
• 2025‑11‑21: Think you can’t interpose static binaries with LD_PRELOAD? What about Qemu?
• 2025‑11‑21: We should all be using dependency cooldown periods.
• 2025‑11‑21: More tales about outages and numeric limits.
• 2025‑11‑21: Exploring the fragmentation of Wayland: an xdotool adventure.
• 2025‑11‑20: How slide rules work.
• 2025‑11‑19: Wavl trees.
• 2025‑11‑18: Designing twisty puzzles: a group theoretical approach.
• 2025‑11‑18: 6 years after too much crypto.
• 2025‑11‑18: Rank-balanced wavl trees.
• 2025‑11‑17: DRAM errors and cosmic rays: space invaders or science fiction?
• 2025‑11‑17: Towards interplanetary QUIC traffic with Rust Quinn.
• 2025‑11‑17: There has to be a better way to make titanium.
• 2025‑11‑17: A clone of the strace command for macOS in Python.
• 2025‑11‑17: JavaScript engines zoo.
• 2025‑11‑16: VapeRE: Reverse engineered disposable vape microcontroller boards.
• 2025‑11‑15: Match it again Sam: Implementing a structural regular expression engine for Rust.
• 2025‑11‑15: Compiler options hardening guide for C and C++.
• 2025‑11‑15: Behind the complaints: investigating the suspicious pressure against archive.today.
• 2025‑11‑15: ucs-detect: automatically test the Unicode version and support level of a terminal emulator.
• 2025‑11‑14: Tour of a Scheme pattern matcher: expression and pattern expansion.
• 2025‑11‑13: Practical security in production: hardening LLVM’s C++ standard library at Apple and Google.
• 2025‑11‑13: PolySubML is broken.
• 2025‑11‑12: Why are sizes signed in the Futhark programming language?
• 2025‑11‑12: `Indexer` and `Int` vs `UInt` in the Mojo programming language.
• 2025‑11‑12: Stroustrup says subscripts and sizes should be signed.
• 2025‑11‑12: A catalog of side effect tracking in compiler IR.
• 2025‑11‑11: Pikaday: A friendly guide to HTML date pickers!
• 2025‑11‑11: Decompression is up to 30% faster in CPython 3.15.
• 2025‑11‑10: Talking Oglaf with Trudy Cooper and Doug Bayne: 'We'd stay up all night drawing stuff to make each other laugh'.
• 2025‑11‑10: Writing your own BEAM in Elm.
• 2025‑11‑10: An interview with William Kahan, the old man of floating-point. (1998)
• 2025‑11‑09: Async Rust with Tokio I/O streams: backpressure, concurrency, and ergonomics.
• 2025‑11‑09: Discovering the discovery of designated resolvers (DNS DDR).
• 2025‑11‑09: Systematization of knowledge (SoK): eternal war in memory. (2013)
• 2025‑11‑09: Experience report: it will never work in theory.
• 2025‑11‑09: Linking and shrinking Rust static libraries.
• 2025‑11‑09: GADT-style trait-constrained enums in Rust.
• 2025‑11‑08: Async DNS with Mac OS getaddrinfo_async_start and Rust smol.
• 2025‑11‑07: readtape: Decode the analog waveform extracted from old computer mag tapes.
• 2025‑11‑07: Exceptions in Cranelift and Wasmtime.
• 2025‑11‑06: A history of man pages.
• 2025‑11‑06: Löb and möb: strange loops in Haskell.
• 2025‑11‑06: How macro expansion works in C.
• 2025‑11‑06: Disassembling vs decompressing terabytes of random data with Zig and Capstone: what are the failure rates?
• 2025‑11‑06: By the power of grayscale!
• 2025‑11‑06: The state of SIMD in Rust in 2025.
• 2025‑11‑05: Stephen Carlsen, Mr TIFF.
• 2025‑11‑05: Quantitative metaphors for sizes in biology.
• 2025‑11‑05: Pipelined Relational Query Language, PRQL: a simple, powerful, pipelined SQL replacement.
• 2025‑11‑04: Vivaldi: a decentralized network coordinate system for predicting RTT.
• 2025‑11‑04: Dennis Ritchie’s story of dabbling in the cryptographic world.
• 2025‑11‑04: Fast GPU bounding boxes on tree-structured scenes via the bracket matching stack monoid.
• 2025‑11‑04: Rust’s `SocketAddrV6` is not roundtrip serializable.
• 2025‑11‑04: The London Ringways map is here.
• 2025‑11‑03: a11y.css: a web page accessibility linter.
• 2025‑11‑03: Homotopy type theory for dummies.
• 2025‑11‑03: Don't give Postgres too much memory.
• 2025‑11‑03: Control structures in programming languages: from goto to algebraic effects.
• 2025‑11‑02: Why doesn’t Isabelle use dependent types?
• 2025‑11‑02: Build system tradeoffs.
• 2025‑11‑02: The CVM algorithm for count-distinct cardinality estimation.
• 2025‑11‑02: Parsing with zippers improves parsing with derivatives.
• 2025‑10‑30: Stop Microsoft users sending 'reactions' to email by adding a postfix header.
• 2025‑10‑30: Titan.DS: LCARS style Star Trek infographic.
• 2025‑10‑30: Notes by djb on using Fil-C with Debian multiarch.
• 2025‑10‑30: Conversions in Ruby are a mess.
• 2025‑10‑30: The math mode problem in Typst.
• 2025‑10‑30: Thread stack layout and ASLR on various unixes.
• 2025‑10‑30: Independently verifying Golang's reproducible builds.
• 2025‑10‑28: Memory safety in Apple Firebloom / iBoot.
• 2025‑10‑28: Situated software.
• 2025‑10‑28: Middle-square Weyl sequence PRNG.
• 2025‑10‑28: Fil-C: A memory-safe C implementation.
• 2025‑10‑28: InvisiCaps: pointers in Fil-C by example.
• 2025‑10‑28: libfringe: an old Rust library for stackful coroutines.
• 2025‑10‑28: Stackful coroutines made fast.
• 2025‑10‑27: Why Busy Beaver hunters fear the Antihydra.
• 2025‑10‑27: The Apple compact unwinding format: documented and explained.
• 2025‑10‑27: asn1c: the Lionet ASN.1 compiler.
• 2025‑10‑26: Fixing rust-lang stdarch issues in LLVM.
• 2025‑10‑26: WebDAV isn't dead yet.
• 2025‑10‑24: How to avoid fighting Rust borrow checker.
• 2025‑10‑24: Image dithering: eleven algorithms and source code.
• 2025‑10‑24: Modern perfect hashing with tricks from computer chess.
• 2025‑10‑23: Tetrapod lamp.
• 2025‑10‑23: I spent a year of my life making an ASN.1 compiler in the D programming language.
• 2025‑10‑23: Awesome tiny crates that make writing Rust more fun.
• 2025‑10‑22: The best – but not good – way to limit string length.
• 2025‑10‑22: Advanced self-aware ed(1).
• 2025‑10‑21: Why SSA?
• 2025‑10‑21: Solving regex crosswords with Z3.
• 2025‑10‑21: RF shielding history: when the FCC cracked down on radio interference from computers.
• 2025‑10‑20: Context parameters and API design in Kotlin.
• 2025‑10‑20: Upcoming Rust language features for kernel development.
• 2025‑10‑19: Linux sched_ext schedulers and tools.
• 2025‑10‑18: Scheme reports at fifty: where do we go from here?
• 2025‑10‑18: Fast calculation of the distance to cubic Bezier curves on the GPU.
• 2025‑10‑18: How I reversed Amazon's Kindle web obfuscation because their app sucks.
• 2025‑10‑16: Pwning Nix through GitHub Actions.
• 2025‑10‑16: paneru: A sliding, tiling window manager for MacOS.
• 2025‑10‑16: mudderjs: lexicographically subdivide the space between strings.
• 2025‑10‑15: Practical seed recovery for the PCG pseudo-random number generator.
• 2025‑10‑15: OSM Perfect Intersection Editor official launch announcement.
• 2025‑10‑15: Gauguin, Descartes, Bayes: a Diurnal Golem’s Brain.
• 2025‑10‑15: From linear types to borrowing.
• 2025‑10‑15: Can we know whether a Java profiler is accurate?
• 2025‑10‑15: Building multi-step web login forms that work well with password managers.
• 2025‑10‑15: Frederik Braun: Modern solutions against cross-site attacks.
• 2025‑10‑14: A modern approach to preventing CSRF in Golang.
• 2025‑10‑14: rumdl: a Markdown linter written in Rust.
• 2025‑10‑14: pglinter: database linting and analysis for PostgreSQL.
• 2025‑10‑14: MPTCP / multipath TCP for Linux.
• 2025‑10‑13: An angry rant about locales and filenames in libarchive.
• 2025‑10‑13: smolBSD: build your own minimal NetBSD system.
• 2025‑10‑13: Why did containers happen?
• 2025‑10‑13: The Peach meme: On CRTs, pixels and signal quality (again).
• 2025‑10‑13: So you want the PostgreSQL JIT to be faster than an interpreter on modern CPUs…
• 2025‑10‑13: A C to Brainfuck compiler written in Rust.
• 2025‑10‑12: Bellcore ManaGeR: running an obscure window system on vintage Linux.
• 2025‑10‑11: StarMalloc: verifying a modern hardened memory allocator.
• 2025‑10‑11: Let's take esoteric programming languages seriously.
• 2025‑10‑11: Eon: a programmable effects-based OCaml DNS server.
• 2025‑10‑11: Synthetic aperture radar autofocus and calibration.
• 2025‑10‑10: Maintaining knowledge about temporal intervals.
• 2025‑10‑09: Signs of AI slop.
• 2025‑10‑08: The Mondrian introduction to functional optics.
• 2025‑10‑07: A proposed Handle trait for Rust.
• 2025‑10‑07: The Gleam programming language is my new obsession.
• 2025‑10‑07: Gleam programming language tour.
• 2025‑10‑07: Electricity transmission network unavailability: the cause of rising wind farm curtailment costs in Britain.
• 2025‑10‑07: Oilfield Units: a measurement system so cursed it made me change career.
• 2025‑10‑07: The evolution of Lua, continued.
• 2025‑10‑06: A case for learning GPU programming with a compute-first mindset.
• 2025‑10‑06: nfc-laboratory: NFC signal and protocol analyzer using SDR receiver.
• 2025‑10‑06: Nanopb: protocol buffers with small code size.
• 2025‑10‑06: buffalo::buffalo::buffalo... in C++.
• 2025‑10‑06: Packing the world for longest lines of sight.
• 2025‑10‑06: Beyond horizons: world-record long-distance photograph 443 km, Finestrelles, Pyrenees – Pic Gaspard, Alps. (2016)
• 2025‑10‑06: Property-based testing of OCaml 5’s runtime system.
• 2025‑10‑05: A new approach to analyzing Robin Hood hashing. (2014)
• 2025‑10‑04: Cuckoo hashing improves SIMD hash tables.
• 2025‑10‑03: What does pointer provenance have to do with RCU?
• 2025‑10‑03: Chapel's runtime types as an interesting alternative to dependent types.
• 2025‑10‑02: Measuring CPU instruction reorder buffer capacity. (2013)
• 2025‑10‑02: Extremely offline: what happened when Tonga was cut off from the internet by a volcanic eruption.
• 2025‑10‑02: A contribution to the development of ALGOL. (Algol W, Wirth & Hoare)
• 2025‑10‑02: Array size types: The biggest semantic mess in Futhark.
• 2025‑10‑01: A content defined chunking algorithm testbed.
• 2025‑10‑01: FastCDC: efficient content-defined chunking for data deduplication.
• 2025‑10‑01: Thanet, Tanit and the Phoenicians: place-names, archaeology and pre-Roman trading settlements in eastern Kent?
• 2025‑09‑30: Temporal_rs is here! The datetime library powering JavaScript Temporal in Boa, Kiesel, and V8.
• 2025‑09‑30: Privacy and security risks in the eSIM ecosystem.
• 2025‑09‑29: Subtleties of SQLite indexes.
• 2025‑09‑29: LIGO can detect daylight savings time.
• 2025‑09‑29: The science behind King's College's wildflower meadows.
• 2025‑09‑29: Code golfing a tiny graphics demo using maths and a pinch of insanity.
• 2025‑09‑29: Optimizing triangles for a full-screen shader pass.
• 2025‑09‑29: Comparing Rust to Carbon.
• 2025‑09‑29: What's new in PostgreSQL 18.
• 2025‑09‑28: RISC-V conditional moves.
• 2025‑09‑28: Supply chain security for the 0.001% (and why it won’t catch on).
• 2025‑09‑27: VBARE / versioned BARE: A simple alternative to Protobuf & Cap'n Proto for schema evolution.
• 2025‑09‑27: BARE messages: binary application record encoding.
• 2025‑09‑27: Is IP fragmentation still considered vulnerable?
• 2025‑09‑27: NFS at 40.
• 2025‑09‑27: Use the force (feedback) to solder small things.
• 2025‑09‑27: Typst: a possible LaTeX replacement.
• 2025‑09‑26: CHERI with a Linux on top.
• 2025‑09‑26: Tuning async IO in PostgreSQL 18.
• 2025‑09‑26: Mixologician: drinking with Datalog.
• 2025‑09‑26: Tracing JITs for Python in the real world.
• 2025‑09‑26: An empirical study of type-related defects in Python projects.
• 2025‑09‑26: Fast UDP I/O for QUIC in Firefox in Rust.
• 2025‑09‑26: Identity types.
• 2025‑09‑26: John Mashey on the difficulty of making a fast VAX.
• 2025‑09‑26: Performance from architecture: comparing a RISC (MIPS) and a CISC (VAX) with similar hardware organization. (1991)
• 2025‑09‑26: Tony Hoare’s hints on programming language design.
• 2025‑09‑25: Some interesting stuff I found on internet exchange LANs.
• 2025‑09‑25: Recursive data structures. (Hoare, 1973)
• 2025‑09‑25: A very early history of algebraic data types.
• 2025‑09‑24: Cooling water options for the new generation of nuclear power stations in the UK.
• 2025‑09‑24: Zeloof Z2 homemade silicon integrated circuit.
• 2025‑09‑24: From Rust through LLVM to asm: the hidden journey of atomic fetch_max.
• 2025‑09‑23: Germicidal ultraviolet could make airborne diseases as rare as those carried by water.
• 2025‑09‑23: Imagining a language without booleans.
• 2025‑09‑22: A deep dive into memory allocation in Golang.
• 2025‑09‑20: The aliens will not be silicon.
• 2025‑09‑19: Design of the SCHEME-78 LISP-based microprocessor.
• 2025‑09‑19: A basis for a mathematical theory of computation. (John McCarthy, 1961-3)
• 2025‑09‑18: Is sound gradual typing dead? Performance problems in Typed Racket.
• 2025‑09‑18: Bluffing in Scrabble.
• 2025‑09‑17: Determination of the fifth Busy Beaver value.
• 2025‑09‑17: The ASUS gaming laptop ACPI firmware bug: a deep technical investigation.
• 2025‑09‑16: Rupert's snub cube and other math holes.
• 2025‑09‑16: The elephant in the biz: outsourcing of critical IT and cybersecurity functions risks UK economic security.
• 2025‑09‑16: Rendezvous hashing explained.
• 2025‑09‑15: On the security of SSH client signatures.
• 2025‑09‑15: Turgot map of Paris (1739).
• 2025‑09‑15: AeroSpace: an i3-like tiling window manager for macOS.
• 2025‑09‑15: The two dualities of computation: negative and fractional (subtraction and division) types.
• 2025‑09‑15: Hosting a website on a disposable vape.
• 2025‑09‑14: Typewriter Pica numbers.
• 2025‑09‑14: TypePulse: detecting type confusion bugs in Rust programs.
• 2025‑09‑14: Setsum: order agnostic, additive, subtractive checksum.
• 2025‑09‑14: foldhash: A fast, non-cryptographic, minimally DoS-resistant hashing algorithm for Rust.
• 2025‑09‑14: The unreasonable effectiveness of modern sort algorithms.
• 2025‑09‑14: ipnsort: an efficient, generic and robust unstable sort implementation.
• 2025‑09‑13: Discontiguous exponential averaging. (1998)
• 2025‑09‑12: The evolution of logical replication in PostgreSQL: a historical overview.
• 2025‑09‑12: Improving state machine code generation in the Rust compiler.
• 2025‑09‑12: Lessons in disabling RC4 in Microsoft Active Directory.
• 2025‑09‑12: Kefir: a new C17/C23 compiler for amd64 unix.
• 2025‑09‑12: Floating point visually explained.
• 2025‑09‑11: The simple essence of overloading: making ad-hoc polymorphism more algebraic with flow-based variational type-checking.
• 2025‑09‑11: Behind the scenes of Bun npm package install.
• 2025‑09‑11: Pairs not taken: a history of twisted pair ethernet.
• 2025‑09‑11: Crimes with Python's pattern matching.
• 2025‑09‑10: Kerberoasting: bad cryptography in Microsoft Windows Active Directory.
• 2025‑09‑10: Memory Integrity Enforcement: A complete vision for memory safety in Apple devices.
• 2025‑09‑09: cargo-crev: A web-of-trust code review system for Rust.
• 2025‑09‑09: Testing the compiler optimizations your code relies on.
• 2025‑09‑09: A new experimental Golang API for JSON.
• 2025‑09‑09: Analyzing the memory ordering models of the Apple M1.
• 2025‑09‑09: Rich Hickey already answered that! Design decisions in Clojure.
• 2025‑09‑09: Byte type: supporting raw data copies in LLVM IR.
• 2025‑09‑09: Pnut: a C to POSIX shell compiler.
• 2025‑09‑09: The government approved Cambridge’s sewage treatment plant upgrade, then withdrew the promised funding.
• 2025‑09‑09: TLD domain name renewal grace periods.
• 2025‑09‑09: Batched critical sections.
• 2025‑09‑09: A novel technique for SQL injection with PHP PDO’s prepared statements.
• 2025‑09‑09: Measuring explicit congestion notification (TCP ECN).
• 2025‑09‑08: Pezy SC: Japan is still investing in custom floating point accelerators.
• 2025‑09‑08: The Brompton-ness of it all: on manufacturing process knowledge.
• 2025‑09‑08: How Britain built some of the world’s safest roads.
• 2025‑09‑08: Hashed radix sort with batched operations is typically faster than a hash table.
• 2025‑09‑08: Concourse: an open-source CI/CD thing-doer.
• 2025‑09‑07: Tony Hoare: How did software get so reliable without proof?
• 2025‑09‑07: MacBook lid angle sensor sound effects.
• 2025‑09‑06: Meschers: geometry processing of impossible objects.
• 2025‑09‑06: Nontransitive comparison functions lead to out-of-bounds read and write in glibc's qsort().
• 2025‑09‑06: Jujutsu megamerges and jj absorb .
• 2025‑09‑06: Dealing with cancel safety in async Rust.
• 2025‑09‑05: Waffle’s revenge: classic 1 bit 8x8 tiling patterns.
• 2025‑09‑05: The type theory fire triangle: how to mix substitution, dependent elimination, and effects.
• 2025‑09‑05: Where did DNSSEC go wrong?
• 2025‑09‑05: You don't need animations.
• 2025‑09‑04: Faster Rust builds on Mac.
• 2025‑09‑03: Wild performance tricks in Rust.
• 2025‑09‑03: Evolution of the ELF object file format.
• 2025‑09‑02: GNU autotools mythbuster.
• 2025‑09‑02: A Theory of Law.
• 2025‑09‑01: Limits of instruction-level parallelism (1991).
• 2025‑09‑01: WeakC4: a search-free low-knowledge solution to 7x6 Connect 4.
• 2025‑09‑01: Unification-free ("keyword") type checking.
• 2025‑09‑01: The beauty of batteries.
• 2025‑09‑01: Why haven't quantum computers factored 21 yet?
• 2025‑09‑01: The Qweremin: a qwerty theremin.
• 2025‑09‑01: Default methods in Golang.
• 2025‑08‑31: We need to seriously think about what to do with C++ modules.
• 2025‑08‑31: Counting large numbers of events in small registers. (1978)
• 2025‑08‑30: Stable mutable references in the Ante programming language.
• 2025‑08‑30: Rust ints to enums with fewer instructions.
• 2025‑08‑30: The cryptographic sponge and duplex constructions.
• 2025‑08‑29: SQLite's durability settings are a mess.
• 2025‑08‑29: CRDTs are built on an elegant kernel, but offer a leaky abstraction that misleads a lot of developers and researchers.
• 2025‑08‑29: Testing time (and other asynchronicities) in Golang.
• 2025‑08‑29: Blocky planet: making Minecraft spherical.
• 2025‑08‑28: A polyhedron without Rupert’s property.
• 2025‑08‑28: A convex polyhedron without Rupert's property: a copy cannot pass via a straight hole through the body.
• 2025‑08‑28: I am an AI hater.
• 2025‑08‑27: How to slow down a program? And why it can be useful.
• 2025‑08‑27: Put a ring on it: a lock-free MPMC ring buffer.
• 2025‑08‑26: Trying to get error backtraces in Rust libraries right.
• 2025‑08‑26: Laws of order: expensive synchronization in concurrent algorithms cannot be eliminated.
• 2025‑08‑26: The origin and unexpected evolution of the word "mainframe".
• 2025‑08‑26: How "special register groups" invaded computer dictionaries for decades.
• 2025‑08‑26: One universal antiviral to rule them all?
• 2025‑08‑26: Emulating aarch64 in software using JIT compilation and Rust.
• 2025‑08‑26: Hedy: textual programming made easy for absolute beginners.
• 2025‑08‑26: How to draw a Space Invader.
• 2025‑08‑25: Nullable vs nullable in C#.
• 2025‑08‑25: Why is cloud file-sharing hard? By analogy with programming misconceptions.
• 2025‑08‑25: The unlikely revival of nuclear batteries.
• 2025‑08‑25: API/ABI changes review for glibc.
• 2025‑08‑25: Timing conclusions: GPS, NTP, PTP timing with Linux.
• 2025‑08‑25: Who's afraid of a hard page load?
• 2025‑08‑25: Everything I know about good HTTP API design.
• 2025‑08‑24: Lomuto’s comeback for quicksort partitions.
• 2025‑08‑23: Elizabeth I and the 'Blackamoors': the deportation that never was.
• 2025‑08‑22: Speed wins when fuzzing Rust code with #[derive(Arbitrary)].
• 2025‑08‑22: The baby paradox in Haskell.
• 2025‑08‑21: A new packaging model for Rust in Guix.
• 2025‑08‑21: Arch Linux AUR chaos malware: an analysis.
• 2025‑08‑21: Indexing JSONB in PostgreSQL.
• 2025‑08‑21: Fun and weirdness with SSDs and PostgreSQL.
• 2025‑08‑21: Sapir-Whorf does not apply to programming languages.
• 2025‑08‑21: Default musl allocator considered harmful to performance.
• 2025‑08‑20: Predecessor search.
• 2025‑08‑20: Why some of us like "interdiff" code review.
• 2025‑08‑20: Code review can be better.
• 2025‑08‑20: Renewable energy unambiguously reduces UK wholesale power prices.
• 2025‑08‑20: Fuss, futexes and furwocks: fast userlevel locking in Linux.
• 2025‑08‑20: Functions are vectors.
• 2025‑08‑20: Atmos: a language for structured concurrency and event-driven programming, based on Lua.
• 2025‑08‑19: Shared memory consistency models: a tutorial. (1996)
• 2025‑08‑19: AsciiDots: an esoteric programming language based on ascii art.
• 2025‑08‑19: The Nickel configuration language.
• 2025‑08‑19: Repairing sequential consistency in C/C++11.
• 2025‑08‑19: Clubcards for the WebPKI: smaller certificate revocation tests in theory and practice.
• 2025‑08‑19: CRLite: fast, private, and comprehensive certificate revocation checking in Firefox.
• 2025‑08‑19: Without the futex, it's futile.
• 2025‑08‑19: The entities enabling scientific fraud at scale are large, resilient, and growing rapidly.
• 2025‑08‑18: Basic dependency injection with objects in OCaml.
• 2025‑08‑18: wrkflw: validate and run Microsoft GitHub Actions locally.
• 2025‑08‑18: Why I prefer reStructuredText to Markdown.
• 2025‑08‑18: Recto: a truly 2D language.
• 2025‑08‑17: Beyond booleans in Lean.
• 2025‑08‑17: A brief consideration of input shapes for fuzzers.
• 2025‑08‑17: A programmer's field guide to assertions.
• 2025‑08‑16: Why everyone gets the Formula 1 inerter wrong.
• 2025‑08‑16: Anaphoric macros introduce hidden bindings in Lisp.
• 2025‑08‑16: Why Lean 4 replaced OCaml as my primary language.
• 2025‑08‑16: The future of large files in Git is Git.
• 2025‑08‑16: What next in programming languages?
• 2025‑08‑14: NaN-propagation: a novel method for sparsity detection in black-box computational functions.
• 2025‑08‑14: Type theory and functional programming. (1999)
• 2025‑08‑13: Snooping on slow builds using syscalls.
• 2025‑08‑13: Ascon lightweight cryptography.
• 2025‑08‑13: Linear scan register allocation on SSA.
• 2025‑08‑13: Type inference for plain data.
• 2025‑08‑13: A comparison of C libraries providing generic containers.
• 2025‑08‑13: The history of an old joke: “From here?!”
• 2025‑08‑12: A tiny (1000 lines), fastish, embeddable scripting language that can be AOT compiled.
• 2025‑08‑11: Why Metropolis–Hastings works.
• 2025‑08‑11: The enduring puzzle of static electricity.
• 2025‑08‑10: Zig's lovely syntax.
• 2025‑08‑10: cargo-remark: view LLVM optimization remarks for Rust.
• 2025‑08‑10: Cracking the Vault: flaws in authentication, identity, and authorization in HashiCorp Vault.
• 2025‑08‑10: Creating high quality electronics schematics.
• 2025‑08‑10: How potatoes evolved.
• 2025‑08‑10: R0ML’s ratio bozo test: Is your volume discount a good deal? Who nose!
• 2025‑08‑08: Hollerith 1890 census tabulator and the evolution of the IBM punched card.
• 2025‑08‑08: The seven virtues of simple type theory / higher-order logic.
• 2025‑08‑08: ChaCha12-BLAKE3: secure, simple and fast authenticated and committing encryption for any CPU.
• 2025‑08‑08: CHICKEN Scheme internals: the garbage collector.
• 2025‑08‑07: You know more Finnish than you think.
• 2025‑08‑07: HTTP/1.1 proxies must die: the desync endgame.
• 2025‑08‑06: Minimal version selection revisited.
• 2025‑08‑06: A proper x86 assembler in Haskell using the Escardó-Oliva functional.
• 2025‑08‑05: ALS Lamon typeface review.
• 2025‑08‑05: Apache ECharts: a JavaScript data visualization / graphing library.
• 2025‑08‑05: AdBlock Tester: test your AdBlock extensions.
• 2025‑08‑05: Can You Block It ? a simple ad block tester.
• 2025‑08‑05: Gate-level emulation of an Intel 4004 in 4004 bytes of C.
• 2025‑08‑05: Rod Bustall: in memoriam.
• 2025‑08‑05: Beyond Markdown: difficulties of the Commonmark specification.
• 2025‑08‑05: Cordoomceps: replacing an Amiga's brain with a Raspberry Pi running Doom.
• 2025‑08‑05: My ideal array language.
• 2025‑08‑05: Grid-scale batteries in Scotland stabilize power with grid-forming inverters.
• 2025‑08‑05: A type designer's take on Indian sign painting.
• 2025‑08‑04: How Google Chrome V8 made JSON.stringify more than twice as fast.
• 2025‑08‑04: Explicit refinement types.
• 2025‑08‑04: A gentle introduction to liquid types.
• 2025‑08‑03: CriTcl: easily embed C code in Tcl.
• 2025‑08‑03: rust-parallel: Run commands in parallel and aggregate outputs, like GNU parallel.
• 2025‑08‑02: Rubik's cube perfect scramble.
• 2025‑08‑01: What declarative languages are.
• 2025‑08‑01: Tracking source locations for profiling GPU programs in Futhark.
• 2025‑08‑01: Making a compiler to prove tmux Is Turing complete.
• 2025‑08‑01: Matrix is email wearing a hoodie.
• 2025‑07‑31: Golang cryptographic assembly mutation testing.
• 2025‑07‑31: Golang's race detector has a mutex blind spot.
• 2025‑07‑31: The math is haunted: an introduction to Lean.
• 2025‑07‑30: How attackers are still phishing "phishing-resistant" passkey authentication.
• 2025‑07‑30: Mosquito Bucket of Death.
• 2025‑07‑30: Poke-a-hole (pahole) and dwarves: examine data structure layouts in DWARF debug info.
• 2025‑07‑30: Flat design vs rich (“skeuomorphic”) design: a bibliography.
• 2025‑07‑30: Activity Monitor anatomy: memory accounting on Mac OS.
• 2025‑07‑30: Programming languages and dimensions of units of measure.
• 2025‑07‑30: Types for units of measure: theory and practice.
• 2025‑07‑30: Typechecking is undecidable when 'type' is a type.
• 2025‑07‑29: Simple and fast derived traits in Rust using rules_derive.
• 2025‑07‑29: Jujutsu for busy devs.
• 2025‑07‑27: The Venetian origins of roman type.
• 2025‑07‑27: MSWasm: soundly enforcing memory-safe execution of unsafe code based on CHERI.
• 2025‑07‑27: How LLVM optimizes power sums with scalar evolution.
• 2025‑07‑27: Implementing a functional language with graph reduction.
• 2025‑07‑26: Rust running on every GPU.
• 2025‑07‑26: Perfecting anti-aliasing on signed distance functions.
• 2025‑07‑26: Slightly better HTML named character reference tokenization for the Ladybird browser.
• 2025‑07‑26: Lecture notes on the π-calculus and Concurrent ML.
• 2025‑07‑26: A new Concurrent ML in Guile Scheme.
• 2025‑07‑24: Coloured pencil nerd's guide to lightfastness.
• 2025‑07‑24: Parsing protobuf like never before.
• 2025‑07‑23: BBC3 The Wrong Door — The Train Pirates.
• 2025‑07‑23: CSS font-size-adjust is useful.
• 2025‑07‑23: Web browser tiny monospace fonts workaround.
• 2025‑07‑23: The Par programming language.
• 2025‑07‑23: JSON is not a subset of YAML.
• 2025‑07‑22: Tony Hoare on record handling. (1965)
• 2025‑07‑22: Tony Hoare on record handling. (1966)
• 2025‑07‑22: John McCarthy’s 1964 proposal for the definition of product and sum types in ALGOL X.
• 2025‑07‑22: Anatomy of a SYN-ACK attack.
• 2025‑07‑21: The key to understanding “Dynamic Programming” is that it’s not referring to “computer programming”.
• 2025‑07‑19: Avoiding COVID with carrageenan nasal spray.
• 2025‑07‑19: The inerter / J-damper: a genius device that rocked Formula 1.
• 2025‑07‑19: Asynchrony is not concurrency.
• 2025‑07‑19: Current technology is not ready for proper alpha blending.
• 2025‑07‑18: Dissonance: a journey through musical possibility space.
• 2025‑07‑18: Dana Scott on the lambda calculus, then and now.
• 2025‑07‑18: A queer history of computing: Peter Landin.
• 2025‑07‑18: Replication of quantum factorisation records with an 8-bit home computer, an abacus, and a dog.
• 2025‑07‑18: Losing programming language features: some stories about sum types / disjoint unions / variant records.
• 2025‑07‑17: The (unfinished) partial differential equation coffee table book.
• 2025‑07‑16: Lower your guards: a compositional pattern-match coverage checker.
• 2025‑07‑16: Linear-time matching of JavaScript regular expressions.
• 2025‑07‑16: GPUHammer: rowhammer attacks on GPU memories are practical.
• 2025‑07‑15: Designing for the eye: optical corrections in architecture and typography.
• 2025‑07‑15: Adding lookbehinds to Rust’s regex crate.
• 2025‑07‑15: How to avoid out-of-thin-air atomics without really trying.
• 2025‑07‑15: Intra-procedural lifetime and borrowing analysis in Clang.
• 2025‑07‑15: A lightweight TCP in UDP tunnel using eBPF for MPTCP.
• 2025‑07‑14: Row polymorphic programming.
• 2025‑07‑14: Binding application in Idris.
• 2025‑07‑14: Strategies for very fast lexers.
• 2025‑07‑14: Stepanov’s biggest blunder in the C++ STL.
• 2025‑07‑13: detour: load the Linux dynamic linker into a statically linked program at run time.
• 2025‑07‑12: CSS performance: Don't animate height!
• 2025‑07‑12: A new Finnish flavor of feline coat coloration, “salmiak”.
• 2025‑07‑11: Faking a JPEG to feed to an abusive web crawler.
• 2025‑07‑11: A hole in Ada type safety.
• 2025‑07‑11: They write the right stuff: software engineering for the Space Shuttle.
• 2025‑07‑10: PostgreSQL LISTEN/NOTIFY does not scale.
• 2025‑07‑10: What's //go:nosplit for in Golang?
• 2025‑07‑10: Optimizing a simple expression parser in Rust.
• 2025‑07‑10: fs_usage: see filesystem activity on Mac OS X.
• 2025‑07‑10: eslogger: trace filesystem events using the Mac OS X endpoint security framework.
• 2025‑07‑08: svg-term-cli: animated terminal sessions using SVG and CSS.
• 2025‑07‑08: Emacs which-key vs Embark for help on prefix keymaps.
• 2025‑07‑08: Find memory errors in unsafe Rust in production with GWP-ASan and the Scudo hardened allocator.
• 2025‑07‑08: PostgreSQL replication slots: preventing WAL bloat and other production issues.
• 2025‑07‑08: A more perfect #[derive] for Rust.
• 2025‑07‑08: Announcing FOKS, the Federated Open Key Service.
• 2025‑07‑08: SIMD.info: searchable reference for C intrinsics.
• 2025‑07‑06: Speed up Magit on MacOS by using git from Homebrew.
• 2025‑07‑06: Developing a transputer ISA board.
• 2025‑07‑06: Get the location of the ISS using DNS.
• 2025‑07‑05: The calculator-on-a-chip.
• 2025‑07‑05: The ITTAGE indirect branch predictor.
• 2025‑07‑03: Firefox's optimized zip format: reading zip files really quickly.
• 2025‑07‑03: The tar archive format, its extensions, and why GNU tar extracts in quadratic time.
• 2025‑07‑03: Portability of tar features.
• 2025‑07‑02: Chess grandmasters do not burn 6000 calories per day.
• 2025‑07‑01: Types of types in Lean: common → exotic.
• 2025‑07‑01: Parsing layout, or: Haskell's syntax is a mess.
• 2025‑07‑01: Fun with git: updating the cached contents in the index by staging.
• 2025‑06‑30: Building accurate postal address matching systems.
• 2025‑06‑30: That boolean should probably be something else.
• 2025‑06‑30: Booleans are a trap.
• 2025‑06‑30: The provenance memory model for C.
• 2025‑06‑28: Map projection transitions.
• 2025‑06‑27: Structuring arrays with algebraic shapes.
• 2025‑06‑27: tinyfeed: Generate a static HTML page from a collection of feed URLs.
• 2025‑06‑26: Text box drawing combinators.
• 2025‑06‑26: Associated vs unassociated alpha channel compositing.
• 2025‑06‑25: Bash, OverlayFS, and a 30-year-old getcwd() bug.
• 2025‑06‑25: xtool: a cross-platform Xcode replacement.
• 2025‑06‑25: A new 3rd edition PNG spec was just released!
• 2025‑06‑25: Reading NFC passport chips in Linux.
• 2025‑06‑25: Taming the bicycle, by Mark Twain.
• 2025‑06‑25: Using LXCFS together with Podman.
• 2025‑06‑24: Forbidden secrets of ancient X11 scaling technology revealed!
• 2025‑06‑24: The one-more-re-nightmare regex engine for Common Lisp.
• 2025‑06‑24: Programming parallel computers.
• 2025‑06‑24: Mechanical watch: exploded view.
• 2025‑06‑24: The modern text rendering pipeline: unicode, bidi, segmentation, shaping, …
• 2025‑06‑24: Bazel’s original sins.
• 2025‑06‑24: Lifetime dispersion and generational GC.
• 2025‑06‑23: How to open a file in Emacs.
• 2025‑06‑23: Making emacs tramp go brrrr.
• 2025‑06‑23: BNFGen: a random text generator based on context-free grammars
• 2025‑06‑22: Basic facts about GPUs.
• 2025‑06‑22: How fast are Linux pipes anyway?
• 2025‑06‑22: Compact representations for arrays in Lua.
• 2025‑06‑22: tayga: NAT64 for Linux.
• 2025‑06‑22: Nearley.js: a toolkit for parsers written in JavaScript.
• 2025‑06‑22: Hask is not a category.
• 2025‑06‑19: Elliptic curves as art.
• 2025‑06‑19: The missing 11th of the month.
• 2025‑06‑18: Posit floating point numbers: thin triangles and other tricks.
• 2025‑06‑18: A collection of articles about retries.
• 2025‑06‑18: Type inference zoo.
• 2025‑06‑18: The web server doesn't render anything.
• 2025‑06‑18: The plight of the misunderstood atomic memory ordering.
• 2025‑06‑18: fx: view and process JSON with JavaScript on the command line.
• 2025‑06‑17: KiCad and Wayland.
• 2025‑06‑17: Nasal sprays for covid prophylaxis.
• 2025‑06‑17: The saga of phkmalloc.
• 2025‑06‑16: Critical analysis of the Meshtastic protocol.
• 2025‑06‑16: Roadmap towards the redefinition of the second.
• 2025‑06‑14: Lambda calculus cooked N ways: Benchmarks for capture-avoiding substitution.
• 2025‑06‑13: Rendering crispy text on the GPU.
• 2025‑06‑13: jemalloc postmortem.
• 2025‑06‑12: The Epic Verse calculus: a core calculus for functional logic programming.
• 2025‑06‑12: A multivalued language with a dependent type system. (A precursor to Epic Verse.)
• 2025‑06‑11: Idris 2: quantitative type theory in practice.
• 2025‑06‑11: Writing a C compiler.
• 2025‑06‑11: A survey of source code sandboxing across unix-like systems.
• 2025‑06‑11: Modern minimal perfect hashing: a survey.
• 2025‑06‑10: Dependent types and program equivalence.
• 2025‑06‑08: The story of ispc: Intel implicit SPMD single program multiple data compiler.
• 2025‑06‑08: Weaponizing dependabot: confused deputy pwn request at its finest.
• 2025‑06‑08: UK High Court to lawyers: cut the ChatGPT or else.
• 2025‑06‑08: Simulating time with square-root space.
• 2025‑06‑08: Making sense of atomic acquire-release semantics.
• 2025‑06‑07: Delta debugging: simplifying and isolating failure-inducing input with automatic test case reduction. (2002)
• 2025‑06‑07: cdimage: A tool for burning visible pictures on a compact disc.
• 2025‑06‑06: Wendelstein 7-X sets new performance records in fusion research.
• 2025‑06‑06: Sharing everything I could understand about gradient noise / Perlin noise.
• 2025‑06‑06: The universal tech tree.
• 2025‑06‑06: Recovering control flow structures from Java bytecode without CFGs.
• 2025‑06‑06: A tutorial implementation of a dependently typed lambda calculus.
• 2025‑06‑06: Implementing dependent types in pi-forall.
• 2025‑06‑06: Magic namerefs in bash.
• 2025‑06‑06: Hokusai Moyo Gafu: an album of dyeing patterns.
• 2025‑06‑06: How common is multiple invention?
• 2025‑06‑06: yeri: JavaScript library for graphing timeseries data into an SVG.
• 2025‑06‑05: From Krivine’s machine to the Caml implementations.
• 2025‑06‑05: Vectorized interpreters: mass rapid transit for programming languages.
• 2025‑06‑05: Unix, Plan 9, and the lurking SmallTalk.
• 2025‑06‑05: The impossible predicament of the death newts.
• 2025‑06‑05: IELR(1): practical LR(1) parser tables for non-LR(1) grammars with conflict resolution.
• 2025‑06‑05: The IELR(1) algorithm for generating minimal LR(1) parser tables for non-LR(1) grammars with conflict resolution.
• 2025‑06‑05: Picking uncontested private IP subnets with usage data.
• 2025‑06‑04: DejaGNU (2011)
• 2025‑06‑04: AMEN: Church numeral addition, multiplication, exponentiation, and nothing are a complete combinator basis.
• 2025‑06‑04: Distance-based ISA for efficient register renaming.
• 2025‑06‑03: From Prometheus to RRDtool graphs.
• 2025‑06‑03: Zero-cost 'tagless initial' in Rust with GADT-style enums.
• 2025‑06‑03: Where did C++ <random> go wrong?
• 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‑02: When do pattern match compilation heuristics matter?
• 2025‑06‑02: Efficient manipulation of binary data using pattern matching.
• 2025‑06‑01: No value restriction is needed for algebraic effects and handlers.
• 2025‑06‑01: Tools built on tree-sitter's concrete syntax trees.
• 2025‑06‑01: The Story of Mel, annotated.
• 2025‑05‑31: Precision Clock Mk IV.
• 2025‑05‑31: Mel's Loop: a comprehensive guide to The Story of Mel.
• 2025‑05‑31: Toxic Origins, Toxic Decisions: bias in CEO selection towards risk-taking, analysed using polluted Superfund sites.
• 2025‑05‑31: Dynamic witnesses for static type errors in OCaml, or, ill-typed programs usually go wrong.
• 2025‑05‑31: Beating the kCTF PoW with AVX512IFMA for $51k.
• 2025‑05‑30: Revisiting Loop Recognition in C++... in Rust.
• 2025‑05‑30: Implementation of dependent types.
• 2025‑05‑30: Parsing distfix operators.
• 2025‑05‑30: Parsing mixfix operators.
• 2025‑05‑29: Making openat(2) and friends more useful in OpenBSD.
• 2025‑05‑29: ΠΣ: dependent types without the sugar.
• 2025‑05‑29: Programming = proving? The Curry-Howard correspondence today.
• 2025‑05‑29: Bootstrapping HTTP/1.1, HTTP/2, and HTTP/3.
• 2025‑05‑29: Why are 2025/05/28 and 2025-05-28 different days in JavaScript?
• 2025‑05‑27: Square theory and unparalleled misalignments in American-style crosswords.
• 2025‑05‑27: BGP handling bug causes widespread internet routing instability.
• 2025‑05‑27: Using otel to emit and view debug traces from Golang command-line tools.
• 2025‑05‑27: Relocation generation in assemblers.
• 2025‑05‑26: Type-level bounded recursion in Rust.
• 2025‑05‑26: Against Curry-Howard mysticism.
• 2025‑05‑26: Microsoft Windows Registry attack surface analysis.
• 2025‑05‑26: A comprehensive list of Wayland compositors.
• 2025‑05‑26: Ironies of automation. (1983)
• 2025‑05‑26: Client rate throttling in the Heroku platform API Ruby gem.
• 2025‑05‑25: Bidirectional typing.
• 2025‑05‑24: There is no Diffie-Hellman but elliptic curve Diffie-Hellman.
• 2025‑05‑23: The curious case of the “pygmy nuthatch” in Charlie’s Angels.
• 2025‑05‑23: How AI botnet DDoS attacks use compromised end-user devices.
• 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: Decibels are ridiculous: celebrating a rare dumpster fire in the kingdom of metrology.
• 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: Writing into uninitialized buffers in Rust.
• 2025‑05‑21: Game math: precise control over numeric springing.
• 2025‑05‑21: Staged compilation with two-level type theory.
• 2025‑05‑21: Dependent types at work in Agda.
• 2025‑05‑21: The NSA selector eurorack module.
• 2025‑05‑20: A Python frozenset interpretation of dependent type theory.
• 2025‑05‑19: Modular type classes.
• 2025‑05‑18: PostgreSQL lock conflicts quick reference.
• 2025‑05‑18: Mystical: a way to write PostScript that looks like a magical circle.
• 2025‑05‑18: Fortran for C programmers.
• 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: rapidhash: a very fast, high quality, platform-independent hashing algorithm.
• 2025‑05‑17: Structured combinators for efficient graph reduction.
• 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: Rustls server-side performance.
• 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: Heron: modern hardware graph reduction.
• 2025‑05‑16: Initialization in C++ is seriously bonkers.
• 2025‑05‑16: I don't like NumPy.
• 2025‑05‑15: Optimizing with novel calendrical algorithms.
• 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: The centenary of the loudspeaker.
• 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‑15: 2025 M7.7 earthquake at Mandalay in Burma / Myanmar.
• 2025‑05‑14: Woodland Trust ancient tree inventory.
• 2025‑05‑14: ZJIT has been merged into Ruby.
• 2025‑05‑14: The mass-energy-information equivalence principle.
• 2025‑05‑14: The first year of free-threaded Python.
• 2025‑05‑14: The database row that did and didn't exist according to Django.
• 2025‑05‑14: Preventing outages with pkill's new --require-handler flag.
• 2025‑05‑13: Intransitive operator precedence: we can do better.
• 2025‑05‑13: Writing that can change how you think about programming languages.
• 2025‑05‑13: wtfis: Passive hostname, domain and IP lookup tool for non-robots.
• 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: Kernighan's lever.
• 2025‑05‑10: In praise of grobi for auto-configuring X11 monitors.
• 2025‑05‑10: Algebraic effects: another mistake carried through to perfection?
• 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: Tantacrul on Finale: how music software dies. (video)
• 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‑06: What is my fuzzer doing? How to get coverage of Rust code.
• 2025‑05‑06: TinyBits: smaller, faster serialization for Ruby apps and beyond.
• 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: What I've learned from jj.
• 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: POSIX shell and utilities quick reference.
• 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: Apple's sillyballs (1988).
• 2025‑04‑30: A collection of quotes on the design of notation as a tool of thought.
• 2025‑04‑30: My sourdough starter has twins.
• 2025‑04‑30: NIST F4 caesium fountain atomic cock joins elite group that keeps the world on time.
• 2025‑04‑30: autosetup: a Tcl-based build environment "autoconfigurator".
• 2025‑04‑30: Swarm testing data structures.
• 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: Bluefishjs: composing diagrams in with declarative relations.
• 2025‑04‑25: Bluefishjs: a diagram drawing framework for JavaScript.
• 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: Exploiting undefined behavior in C/C++ programs for optimization: a study on the performance impact.
• 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‑21: Python's new template t-strings.
• 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: RE#: high performance derivative-based regex matching with intersection, complement, and lookarounds.
• 2025‑04‑17: Graham: synchronizing clocks by measuring server temperature.
• 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: Getting started with the W65C832 FPGA core, a 32 bit extended 6502.
• 2025‑04‑15: Sunlight: a certificate transparency implementation built for scalability, ease of operation, and reduced cost.
• 2025‑04‑15: What the hell Is a target triple?
• 2025‑04‑15: Algebraic semantics for machine knitting.
• 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: Unlocking sudoku's secrets with graph theory and abstract algebra.
• 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‑13: 10 years of pomological watercolors.
• 2025‑04‑12: Why is there a "small house" in IBM's code page 437?
• 2025‑04‑12: Weird architectures weren't supported to begin with.
• 2025‑04‑12: WebRTC for the curious.
• 2025‑04‑12: awe: A compiler for the Algol W programming language.
• 2025‑04‑12: Molecules with silly or unusual names.
• 2025‑04‑11: What is algebraic about algebraic effects and handlers?
• 2025‑04‑11: Walking the London Loop.
• 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: Computer science Logo style.
• 2025‑04‑10: A discipline of error handling.
• 2025‑04‑10: Practical UNIX manuals with mdoc: structure, style, and composition.
• 2025‑04‑09: I Got Plenty o’ Nuttin’: linear dependent types.
• 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: netbird: Connect your devices into a WireGuard overlay network with SSO, MFA and granular access controls.
• 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: Some pitfalls of safe Rust.
• 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: A brief history of Erlang’s BEAM compiler.
• 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‑30: Let's create a Tree-sitter grammar.
• 2025‑03‑29: Compiler construction textbook by Niklaus Wirth.
• 2025‑03‑29: A language server protocol (LSP) implementation for PostgreSQL.
• 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: Succinct data structures.
• 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‑25: The Prospero challenge.
• 2025‑03‑24: faer: a general-purpose linear algebra library for Rust.
• 2025‑03‑24: Cool but obscure X11 tools.
• 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: μFork: a pure actor-based concurrent machine architecture with memory-safety and object-capability security.
• 2025‑03‑22: SKIM: The implementation of functional languages using custom hardware.
• 2025‑03‑22: HAFLANG: hardware acceleration of functional languages.
• 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‑18: Portable dynamically linked packages on Linux.
• 2025‑03‑17: A review of the Helix editor after 1.5 years.
• 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: Historic tale construction kit: make your own Bayeux tapestry.
• 2025‑02‑28: It's the latency, stupid!
• 2025‑02‑28: A survey of every iterator variant in Rust.
• 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: Arithmetic with continued fractions.
• 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: Taichi: high-performance parallel programming in Python.
• 2025‑02‑15: Gorton recreations.
• 2025‑02‑15: Post-mortem of network outage affecting OpenStreetMap.org in December 2024.
• 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‑14: Homemade polarimetric synthetic aperture radar drone.
• 2025‑02‑13: libu8ident: Unicode security guidelines for programming language identifiers.
• 2025‑02‑13: Building a hyper-personalized seach engine that isn't very good.
• 2025‑02‑13: On Jujutsu and Magit.
• 2025‑02‑13: A fast 6502 code generator.
• 2025‑02‑11: A catalog of ways that compilers generate SSA.
• 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: Updating a large codebase to Rust 2024.
• 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‑05: Mach-O linking and loading tricks.
• 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: Why the north of England is poor.
• 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: Guided by the beauty of our test suite: snapchot texting, fuzz testing, and panic freedom in Rust.
• 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‑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: Why is my Chumby’s CPU usage always 100%?
• 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: SIMD in Rust: you do not need multithreading to do more than one thing at a time.
• 2025‑01‑10: Peter Kirstein describes how Britain got its first Internet connection.
• 2025‑01‑10: Soldering the Tektronix way.
• 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‑07: Servo revival 2023-2024.
• 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: Reliable system call interception with Linux seccomp.
• 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: Remote reboots with encrypted disks on Arch Linux.
• 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‑20: CandyFab: a DIY 3D sugar printer.
• 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: Golang's weird little iterators.
• 2024‑12‑17: UK Online Safety Act Notes for small sites.
• 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: Legacy safety: the Wrocław C++ wg21 meeting.
• 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: The SLAX scripting language: an alternative syntax for XSLT.
• 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: gofumpt: a stricter gofmt.
• 2024‑11‑23: copycat: intercept system calls using seccomp.
• 2024‑11‑22: Runtime-extensible PEG parsers for SQL.
• 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: Tiling with three polygons is undecidable.
• 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.

---