Tony Finch – link log

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

• 2025‑06‑18: Posit floating point numbers: thin triangles and other tricks.
• 2025‑06‑13: jemalloc postmortem.
• 2025‑06‑12: A multivalued language with a dependent type system. (A precursor to Epic Verse.)
• 2025‑06‑10: Dependent types and program equivalence.
• 2025‑06‑08: Weaponizing dependabot: confused deputy pwn request at its finest.
• 2025‑06‑08: Simulating time with square-root space.
• 2025‑06‑06: Implementing dependent types in pi-forall.
• 2025‑06‑06: Hokusai Moyo Gafu: an album of dyeing patterns.
• 2025‑06‑05: IELR(1): practical LR(1) parser tables for non-LR(1) grammars with conflict resolution.
• 2025‑06‑04: DejaGNU (2011)
• 2025‑06‑04: Distance-based ISA for efficient register renaming.
• 2025‑06‑03: Zero-cost 'tagless initial' in Rust with GADT-style enums.
• 2025‑06‑03: What's higher-order about so-called higher-order references?
• 2025‑06‑03: How to take the inverse of a type.
• 2025‑06‑02: Pattern matching and exhaustiveness checking algorithms implemented in Rust.
• 2025‑06‑01: Tools built on tree-sitter's concrete syntax trees.
• 2025‑05‑31: Precision Clock Mk IV.
• 2025‑05‑31: Toxic Origins, Toxic Decisions: bias in CEO selection towards risk-taking, analysed using polluted Superfund sites.
• 2025‑05‑31: Beating the kCTF PoW with AVX512IFMA for $51k.
• 2025‑05‑30: Implementation of dependent types.
• 2025‑05‑29: ΠΣ: dependent types without the sugar.
• 2025‑05‑26: Type-level bounded recursion in Rust.
• 2025‑05‑26: Microsoft Windows Registry attack surface analysis.
• 2025‑05‑25: Bidirectional typing.
• 2025‑05‑24: There is no Diffie-Hellman but elliptic curve Diffie-Hellman.
• 2025‑05‑23: That fractal that's been up on my wall for 12 years.
• 2025‑05‑22: Designing APIs for humans: Stripe object IDs.
• 2025‑05‑22: Fast allocations in Ruby 3.5.
• 2025‑05‑22: Violating memory safety with Haskell's value restriction.
• 2025‑05‑22: Blazingly fast™ type class resolution with a trie.
• 2025‑05‑22: Violating memory safety with Haskell's value restriction.
• 2025‑05‑22: Gradients are the new intervals for signed distance function evaluation.
• 2025‑05‑21: The magic of software; or, what makes a good engineer also makes a good engineering organization.
• 2025‑05‑21: Dependent types at work in Agda.
• 2025‑05‑19: Modular type classes.
• 2025‑05‑18: PostgreSQL lock conflicts quick reference.
• 2025‑05‑17: The programming language that never was.
• 2025‑05‑17: Japan's IC cards are weird and wonderful.
• 2025‑05‑17: O2 VoLTE: locating any customer with a phone call.
• 2025‑05‑17: CHERIoT: the last ten years.
• 2025‑05‑17: Don’t use ISO/IEC 14977 Extended Backus-Naur Form (EBNF).
• 2025‑05‑17: Programming in Martin-Lof's type theory: an introduction. (1990)
• 2025‑05‑17: MicroHs: Haskell implemented with combinators by Lennart Augustsson.
• 2025‑05‑16: Pallene: a statically typed ahead-of-time compiled sister language to Lua, with a focus on performance.
• 2025‑05‑16: Lock-free Rust: how to build a rollercoaster while it’s on fire.
• 2025‑05‑16: From Haskell to a new structured combinator processor for graph reduction in hardware.
• 2025‑05‑16: Reservoir sampling: who discovered Algorithm R?
• 2025‑05‑16: Cloaca: a concurrent hardware garbage collector for non-strict functional languages.
• 2025‑05‑16: Initialization in C++ is seriously bonkers.
• 2025‑05‑15: A leap year check in three instructions.
• 2025‑05‑15: How did REST come to mean the opposite of REST?
• 2025‑05‑15: Fixing the traffic jam in the science of technology safety.
• 2025‑05‑15: Diagnosing a double-free concurrency bug in Rust's unbounded channels.
• 2025‑05‑15: 10 years of stable Rust: an infrastructure story.
• 2025‑05‑15: Crossness pumping station: seduced by symmetry.
• 2025‑05‑15: A Rust API inspired by Python, powered by Serde.
• 2025‑05‑14: The first year of free-threaded Python.
• 2025‑05‑14: Preventing outages with pkill's new --require-handler flag.
• 2025‑05‑13: YamlScriot: YAML done wisely.
• 2025‑05‑12: De Bruijn's combinatorics.
• 2025‑05‑12: Load-store conflicts.
• 2025‑05‑11: Alan Kay did not invent object-oriented programming.
• 2025‑05‑10: Castle Kellmore 2.5D rendering on the PlayDate handheld game console.
• 2025‑05‑10: Beating the fastest lexer generator in Rust.
• 2025‑05‑10: Stacking lookup tables in a lexer generator.
• 2025‑05‑09: Static interpretation of higher-order modules in Futhark: functional GPU programming in the large.
• 2025‑05‑08: Implement your programming language twice.
• 2025‑05‑07: The state of SSL/TLS stacks.
• 2025‑05‑06: A continuation-passing evaluation semantics for classical proofs.
• 2025‑05‑06: A formulae-as-type notion of control: classical logic and call/cc in Scheme.
• 2025‑05‑06: Propositions as types.
• 2025‑05‑05: Archers did not volley fire.
• 2025‑05‑05: Helmdar: 3D scanning Brooklyn on rollerblades.
• 2025‑05‑05: On the design of compact elastic binary trees (cebtree).
• 2025‑05‑04: Pixels in Islamic art: square Kufic calligraphy.
• 2025‑05‑02: Adaptive hashing in SBCL.
• 2025‑05‑02: Optimizing programs written in Guile Scheme.
• 2025‑05‑02: The one ring problem: abstraction and our quest for power.
• 2025‑05‑02: Elm property-based test case distributions.
• 2025‑05‑02: Designing type inference for high quality type errors.
• 2025‑05‑01: roons: modular marble logic.
• 2025‑05‑01: verb: Emacs org mode HTTP client.
• 2025‑04‑30: A collection of quotes on the design of notation as a tool of thought.
• 2025‑04‑30: BBC 1 logo 1985: a computer originated world.
• 2025‑04‑29: Let's Debug figures out why you can’t issue a certificate with Let's Encrypt.
• 2025‑04‑29: Syntactic musings on match expressions in Rust.
• 2025‑04‑27: DIY book lamp: simple electronics meets paper craft.
• 2025‑04‑27: Technical debt as theory building and practice.
• 2025‑04‑27: Silent bugs matter: a study of compiler-introduced security bugs.
• 2025‑04‑26: Visibly pushdown languages: between regular and context-free.
• 2025‑04‑26: Parallel ./configure
• 2025‑04‑26: Venera 8 Kosmos 482 descent craft reentry forecasts.
• 2025‑04‑25: The Bayeux Tapestry with knobs on: what do its 93 penises tell us?
• 2025‑04‑25: setenv() isn't threadsafe and even safe Rust didn't save us.
• 2025‑04‑25: Logarithms of algebraic data types for property-based testing.
• 2025‑04‑23: Danglepoise raise/lower dining table lights.
• 2025‑04‑23: What is cosh(List(Bool))? Or beyond algebra: analysis of data types.
• 2025‑04‑23: Does using Rust really make DNS name decompression safer?
• 2025‑04‑23: PiDP-11 and other replicas of old computers.
• 2025‑04‑23: Detecting if an expression is constant in C.
• 2025‑04‑20: Things Zig comptime won't do.
• 2025‑04‑19: Breaking down multipart parsers: file upload validation bypass.
• 2025‑04‑19: 15,000 lines of verified cryptography now in Python.
• 2025‑04‑18: Decomposing transactional systems.
• 2025‑04‑18: Marching Events: What does iCalendar have to do with ray marching?
• 2025‑04‑18: Sneak peek: A new ASN.1 API for Python.
• 2025‑04‑18: Exacerbating cross-site scripting: the iframe sandwich.
• 2025‑04‑18: NIST uncertainty machine.
• 2025‑04‑18: Dissolving the Fermi paradox.
• 2025‑04‑18: Squiggle: a simple programming language for intuitive probabilistic estimation.
• 2025‑04‑18: Probabilistic programming: doing statistics using the tools of computer science.
• 2025‑04‑17: An iOS dlsym() PAC calculation bug.
• 2025‑04‑17: The halting problem is a terrible example of NP-harder.
• 2025‑04‑16: Atomicless concurrency.
• 2025‑04‑16: Learning rate: What does it mean for a technology (such as solar power) to follow Wright’s Law?
• 2025‑04‑15: The .su ccTLD might be safe after all.
• 2025‑04‑15: Two years of Rust.
• 2025‑04‑15: Sunlight: a certificate transparency implementation built for scalability, ease of operation, and reduced cost.
• 2025‑04‑15: A cautionary tale about continuity in constructive solid geometry.
• 2025‑04‑15: Fun with -fsanitize=undefined and Picolibc.
• 2025‑04‑14: Flat origami is Turing complete.
• 2025‑04‑14: Clowns to the left of me, jokers to the right: dissecting and dividing algebraic data structures.
• 2025‑04‑13: Dijkstra on mathematical notation.
• 2025‑04‑12: Why is there a "small house" in IBM's code page 437?
• 2025‑04‑12: WebRTC for the curious.
• 2025‑04‑12: awe: A compiler for the Algol W programming language.
• 2025‑04‑11: What is algebraic about algebraic effects and handlers?
• 2025‑04‑11: London Cycle Orbital: peaceful cycling at London's margins.
• 2025‑04‑11: Why do AI company logos look like arseholes?
• 2025‑04‑11: The yaml document from hell.
• 2025‑04‑11: What do bodies think about?
• 2025‑04‑11: Situated software.
• 2025‑04‑10: A discipline of error handling.
• 2025‑04‑10: Practical UNIX manuals with mdoc: structure, style, and composition.
• 2025‑04‑09: facet: type reflection, serialization, deserialization — know the shape of your types in Rust.
• 2025‑04‑08: Obituary for Doug Lenat’s Cyc, the greatest monument to logical AGI.
• 2025‑04‑08: On the complexity and performance of parsing with derivatives.
• 2025‑04‑07: A rough survey of compilation, recompilation, and compile-time evaluation.
• 2025‑04‑06: How to sync anything.
• 2025‑04‑06: When should a Java JIT compiler expand garbage collection barriers?
• 2025‑04‑04: On JavaScript's weirdness.
• 2025‑04‑04: The crisis of zombie social science.
• 2025‑04‑03: How Java got the generics it has, or, how I learned to stop worrying and love type erasure.
• 2025‑04‑02: Gerrit, GitButler, and Jujutsu projects collaborating on a change-id commit footer.
• 2025‑04‑01: Electron band structure in germanium, my ass.
• 2025‑03‑31: WALI: WebAssembly with thin Linux kernel interfaces.
• 2025‑03‑31: There’s white stuff growing on your cheese that isn’t mold.
• 2025‑03‑31: LALRPOP: a parser generator for Rust.
• 2025‑03‑31: Incremental zero-config code navigation using stack graphs with tree-sitter at GitHub.
• 2025‑03‑31: comrak: a CommonMark and GFM compatible Markdown parser and renderer in Rust.
• 2025‑03‑31: sharun: run dynamically linked ELF binaries everywhere.
• 2025‑03‑31: Policy for the distribution of ISO publications and the protection of ISO’s copyright: ISO POCOSA 2012.
• 2025‑03‑30: Hacker laws, theories, principles, and patterns that developers will find useful.
• 2025‑03‑30: Towards fearless SIMD in Rust, 7 years later.
• 2025‑03‑30: Learn CSS layout the pedantic way.
• 2025‑03‑29: Compiler construction textbook by Niklaus Wirth.
• 2025‑03‑28: Better Binary Quantization (BBQ) in Lucene and Elasticsearch.
• 2025‑03‑28: Specifying Wasm with SpecTec.
• 2025‑03‑28: Wasm SpecTec has been adopted.
• 2025‑03‑28: Xee: a modern XPath and XSLT engine in Rust.
• 2025‑03‑27: RSS/Atom feed best practise.
• 2025‑03‑27: The Verilog preprocessor: force for `good and `evil
• 2025‑03‑26: Pi Pico Rx: a crystal radio for the digital age?
• 2025‑03‑26: Build better Golang release binaries.
• 2025‑03‑26: An epic treatise on error models for systems programming languages.
• 2025‑03‑25: On the ignorability of attributes in C++.
• 2025‑03‑25: Database protocols are underwhelming.
• 2025‑03‑24: faer: a general-purpose linear algebra library for Rust.
• 2025‑03‑24: CSS animation with offset-path.
• 2025‑03‑23: Carl Linnaeus's note-taking innovations.
• 2025‑03‑23: browse-at-remote: browse remote code forges with emacs.
• 2025‑03‑23: gif320: A GIF viewer for DEC VT320 terminals.
• 2025‑03‑22: Imberbus: a classic bus service across the Salisbury Plain to the lost village of Imber.
• 2025‑03‑22: A critical bibliography about the pirate site LibGen.
• 2025‑03‑22: SKIM: The implementation of functional languages using custom hardware.
• 2025‑03‑22: Brotli compression for the web.
• 2025‑03‑21: MySQL transactions per second vs fsyncs per second.
• 2025‑03‑21: Shaarli: personal, minimalist, super-fast, database free, bookmarking service.
• 2025‑03‑21: I want a good parallel computer.
• 2025‑03‑20: Fear and loathing of the English passive.
• 2025‑03‑18: y-cruncher: a multi-threaded Pi program.
• 2025‑03‑16: Performance of Git's new bundle-uri.
• 2025‑03‑16: Extracting content from an LCP “protected” ePub.
• 2025‑03‑15: Displaying Korean text efficiently.
• 2025‑03‑14: HashChain: a family of very fast factor-based sublinear exact-matching string search algorithms.
• 2025‑03‑14: Hash Chain: efficient exact online string search / matching through linked weak factors.
• 2025‑03‑14: PAM unixsock.
• 2025‑03‑13: Nanowar Of Steel - HelloWorld.java
• 2025‑03‑13: Triangle of power notation: exponents roots and logarithms.
• 2025‑03‑13: When is "this trait can be implemented" part of the trait's public API? Sealed traits in Rust with cargo-semver-checks.
• 2025‑03‑12: Constant-time code: the pessimist’s case.
• 2025‑03‑12: On the state of coherence in the land of type classes.
• 2025‑03‑12: Representing type lattices compactly.
• 2025‑03‑11: Owi: performant parallel symbolic execution made easy with OCaml and WebAssembly.
• 2025‑03‑11: Backyard cyanide from the cherry laurel.
• 2025‑03‑11: Far-UVC: germicidal ultraviolet light can inactivate a wide range of pathogens with minimal effects on human tissues.
• 2025‑03‑09: Performance of the Python 3.14 tail-call interpreter.
• 2025‑03‑09: Efficient communication and garbage collection in Haskell with compact normal forms.
• 2025‑03‑09: Keep calm and panic: performance of errors in Golang.
• 2025‑03‑09: Performance of returning errors vs. exceptions in Go and C++.
• 2025‑03‑07: JA4+: a suite of network fingerprinting standards.
• 2025‑03‑06: The Combined Cipher Machine, 1942-1962.
• 2025‑03‑05: Encoding Hangeul, Koreas writing system.
• 2025‑03‑04: Eradicating trivial vulnerabilities, at scale.
• 2025‑03‑02: Hardware discovery: ACPI and Device Tree.
• 2025‑03‑01: A dictionary of affixes: the building blocks of English.
• 2025‑02‑28: It's the latency, stupid!
• 2025‑02‑28: How CouchDB prevents data corruption with fsync.
• 2025‑02‑28: The Fibrovisor: a display made from a tat shop fibre-optic wand.
• 2025‑02‑28: Notes: long-form comments in GHC.
• 2025‑02‑27: But can DOOM run it? Programming satan’s computer.
• 2025‑02‑27: Can Doom run it? Adding with NAND gates in Doom.
• 2025‑02‑27: Socrates is a state machine: sans IO with async Rust.
• 2025‑02‑27: macOS tips and tricks.
• 2025‑02‑27: Efficient communication and collection with compact normal forms in Haskell.
• 2025‑02‑26: The miserable state of cellular modems and mobile network operators.
• 2025‑02‑25: Proving a stupid sort algorithm with Dafny.
• 2025‑02‑25: How core git developers configure git.
• 2025‑02‑22: How to write mathematics. (1973)
• 2025‑02‑22: Neut: a functional programming language with static memory management.
• 2025‑02‑20: A tail calling interpreter for Python, and other musttail updates.
• 2025‑02‑20: TRAVERTINE: CVE-2025-24118 safe memory reclamation race in the XNU Mac OS kernel.
• 2025‑02‑17: How does Ada's memory safety compare with Rust’s?
• 2025‑02‑17: 0+0 > 0: C++ thread-local storage performance.
• 2025‑02‑16: Program logics à la carte.
• 2025‑02‑16: Small-data computing: Hans-J Boehm’s correct calculator arithmetic.
• 2025‑02‑16: Unexpected uses of the GF2P8AFFINEQB bit matrix multiply instruction.
• 2025‑02‑16: Spin: formal verification of multi-threaded code.
• 2025‑02‑16: CPL elementary programming manual.
• 2025‑02‑16: Gaussian random number generators.
• 2025‑02‑15: Gorton recreations.
• 2025‑02‑15: Unofficial Jepsen test of Patroni, a PostgreSQL high availability solution.
• 2025‑02‑15: Gorton: The hardest working font in Manhattan.
• 2025‑02‑14: TeX and Typst layout models.
• 2025‑02‑14: Type safe variadic printf in Idris.
• 2025‑02‑14: Switching on strings in Zig.
• 2025‑02‑14: Intensional Joy: a concatenative account of internal structure.
• 2025‑02‑13: On Jujutsu and Magit.
• 2025‑02‑13: A fast 6502 code generator.
• 2025‑02‑11: Elementary functions NOT following the IEEE 754 floating-point standard.
• 2025‑02‑11: An approach to generate correctly rounded math libraries for new floating point variants.
• 2025‑02‑11: The `satisfies` operator in TypeScript.
• 2025‑02‑11: Optimal bounds for open addressed hash tables without reordering.
• 2025‑02‑10: Dazed and Confused: a large-scale real-world user study of reCAPTCHAv2.
• 2025‑02‑09: blip: A tool for seeing your Internet latency.
• 2025‑02‑09: Getting the type of a template argument as string in C++ without RTTI.
• 2025‑02‑08: From hours to 360ms: over-engineering a puzzle solution.
• 2025‑02‑08: Tips for mathematical handwriting.
• 2025‑02‑08: Fend: an arbitrary-precision unit-aware calculator.
• 2025‑02‑08: Turner, Bird, O’Neill, and the sieve of Eratosthenes.
• 2025‑02‑08: Colossus: the first large-scale electronic computer.
• 2025‑02‑08: Mustang: Rust programs written entirely in Rust.
• 2025‑02‑07: PolySubML: A simple ML-like language with subtyping, polymorphism, higher rank types, and global type inference.
• 2025‑02‑07: Rink: an open source unit-aware calculator.
• 2025‑02‑07: Numbat: A statically typed programming language for scientific computations with first class support for physical dimensions and units of measure.
• 2025‑02‑07: Profiling in production with function call traces.
• 2025‑02‑07: Periodic cooking of eggs.
• 2025‑02‑06: Three basic rules of safety hygiene in Rust.
• 2025‑02‑06: Thoughts after months of using Zig.
• 2025‑02‑05: The Sudoku affair.
• 2025‑02‑04: Delilah: Alan Turing’s secret wartime voice encryption project.
• 2025‑02‑04: Decorator JITs: Python as a DSL.
• 2025‑02‑04: No-panic Rust: a nice technique for systems programming.
• 2025‑02‑04: Notes on type layouts and ABIs in Rust.
• 2025‑02‑04: A developer’s philosophy.
• 2025‑02‑03: Pinning down "Future is not Send" errors in async Rust.
• 2025‑02‑03: A caveat with statically linked language runtimes.
• 2025‑02‑02: Hollywood: split a computer console into multiple panes of genuine technical melodrama.
• 2025‑02‑02: Introducing sealed capability types for CHERIoT.
• 2025‑02‑02: Parametric subtyping for structural parametric polymorphism.
• 2025‑02‑02: Conway's law: how do committees invent?
• 2025‑02‑02: An interview with James H Wilkinson: early numerical methods with electronic computers.
• 2025‑02‑01: Enabling Touch ID for sudo on macOS, before and after Sonoma.
• 2025‑01‑31: Jujutsu VCS introduction and patterns.
• 2025‑01‑31: Falsehoods programmers believe about null pointers.
• 2025‑01‑31: Byte queue limits for Linux network drivers.
• 2025‑01‑31: Why is unauthenticated encryption insecure?
• 2025‑01‑31: Adding garbage collection to our Rust-based interpreters with MMTk.
• 2025‑01‑30: A home built pipe organ.
• 2025‑01‑30: Scaling the Let’s Encrypt rate limits to prepare for a billion active TLS certificates.
• 2025‑01‑28: A retrospective on SCCS, the Source Code Control System.
• 2025‑01‑26: Use monoids for construction.
• 2025‑01‑25: The invalid 68030 instruction that accidentally allowed the Mac Classic II to successfully boot up.
• 2025‑01‑25: Advent of code 2024 in the BQN array programming language.
• 2025‑01‑25: Proper decoupling practices, and why you should leave 100nF behind.
• 2025‑01‑25: World's first MIDI shellcode: remote code execution on a synthesizer.
• 2025‑01‑24: Compile-time speed analysis of compiler frameworks for database query compilation.
• 2025‑01‑23: The mythical IO-bound Ruby on Rails app.
• 2025‑01‑23: Why PostgreSQL major version upgrades are hard.
• 2025‑01‑23: See a PostgreSQL query, byte by byte, over TLS.
• 2025‑01‑22: The London Underground is too hot, but it’s not an easy fix.
• 2025‑01‑22: Compiler fuzzing in continuous integration: a case study on Dafny.
• 2025‑01‑22: get_secrets: Negotiate symmetric secrets between two remote peers using mTLS secret exporter.
• 2025‑01‑22: How to unlock LUKS using Dropbear SSH keys remotely in Linux.
• 2025‑01‑22: Mercator: Extreme.
• 2025‑01‑21: The hunt for EINVAL in embedded Rust.
• 2025‑01‑20: InAppBrowser.com: see what JavaScript commands get injected.
• 2025‑01‑20: Hash function design, SMHasher and Goodhart's Law.
• 2025‑01‑20: The "35-cent" Commodore 64 softmodem.
• 2025‑01‑20: Automatic server reloading on change in Rust with listenfd and systemfd.
• 2025‑01‑19: The surprising struggle to get a UNIX epoch time from a UTC string in C or C++.
• 2025‑01‑19: Hasochism: the pleasure and pain of dependently typed haskell programming.
• 2025‑01‑18: Hands-on graphics with the NetBSD console.
• 2025‑01‑17: Responsible disclosure is wrong.
• 2025‑01‑17: Get a random selection of lines in a file using reservoir sampling in Rust.
• 2025‑01‑16: COW vs BEEF: busting the biggest etymology myth in linguistic history.
• 2025‑01‑16: ai.robots.txt: A list of AI agents and robots to block.
• 2025‑01‑16: ipcc-downloader: download iOS cellular carrier profiles.
• 2025‑01‑16: Is Wasm Memory64 actually worth using?
• 2025‑01‑16: The mess that is handling structure arguments and returns in LLVM.
• 2025‑01‑15: Fenwick trees are awesome!
• 2025‑01‑15: Das Blinkenlights!
• 2025‑01‑14: NREVERSAL of fortune: the thermodynamics of garbage collection.
• 2025‑01‑14: Phil Rogaway on radical computer science.
• 2025‑01‑13: Fluid simulation pendant.
• 2025‑01‑13: The missing JIT tier for SQL query compilers.
• 2025‑01‑13: Accurate benchmarking: how to account for the loop overhead.
• 2025‑01‑13: Underrated ways to change the world.
• 2025‑01‑13: Doug Lenat's source code for AM and EURISKO.
• 2025‑01‑12: exec-path-from-shell: Make Emacs use the $PATH set in your shell.
• 2025‑01‑12: Backdooring your backdoors: another $20 domain, more governments.
• 2025‑01‑12: From ASCII to ASIC: Porting donut.c to a tiny slice of silicon.
• 2025‑01‑12: What do long-term prices tell us about mineral resource scarcity?
• 2025‑01‑12: Why I chose Common Lisp.
• 2025‑01‑11: The double mmap() magic ring buffer.
• 2025‑01‑11: Rewrite it in Rust: a computational physics case study.
• 2025‑01‑11: Building Bauble: interactive signed distance functions with WebGL.
• 2025‑01‑11: Containerless plurals: separating number from type in object-oriented programming.
• 2025‑01‑11: Jef Raskin: Intuitive equals familiar. (1994)
• 2025‑01‑10: Bad Apple but it's 6,500 regexes that I search for in vim.
• 2025‑01‑10: How to miscompile programs with “benign” data races.
• 2025‑01‑10: Pushing the whole company into the past on purpose: deploying leap second smear at Facebook in 2015.
• 2025‑01‑10: Peter Kirstein describes how Britain got its first Internet connection.
• 2025‑01‑09: The design recipe from “how to design programs”.
• 2025‑01‑09: dnsclay: DNS UPDATE/AXFR/NOTIFY to many custom DNS operator APIs gateway
• 2025‑01‑09: SQL NULLs are weird!
• 2025‑01‑09: WorstFit: hidden transformations in Windows character sets.
• 2025‑01‑09: Rethinking errors, warnings, and lints.
• 2025‑01‑08: De-smarting the Marshall Uxbridge bluetooth speaker.
• 2025‑01‑08: Fidget: a library for representing implicit surfaces.
• 2025‑01‑07: Zig's comptime is bonkers good.
• 2025‑01‑07: Building ultra long range TOSLINK.
• 2025‑01‑06: Collatzeral damage: bitwise and proof foolish.
• 2025‑01‑06: Cray 1 supercomputer performance comparisons with home computers.
• 2025‑01‑06: Lord of the io_uring.
• 2025‑01‑05: D2: declarative diagramming, implemented in Golang.
• 2025‑01‑05: Academic urban legends: spinach as a source of iron.
• 2025‑01‑05: Don't clobber the frame pointer when writing asm for Golang.
• 2025‑01‑05: The evolution of tunnel boring machines.
• 2025‑01‑04: Phase behavior of Cacio e Pepe sauce.
• 2025‑01‑04: FIFO queues are all you need for cache eviction.
• 2025‑01‑04: UltraLogLog: a practical and more space-efficient alternative to HyperLogLog for approximate distinct counting.
• 2025‑01‑04: Common Package Specification: a year closer to standard C++ dependency management.
• 2025‑01‑04: 1ML: core and modules united.
• 2025‑01‑04: The state of Garnet in 2025.
• 2025‑01‑03: The Intel Alder Lake SHLX anomaly.
• 2025‑01‑03: Can PostgreSQL use this index, please?
• 2025‑01‑02: The Fish of Theseus port from C++ to Rust.
• 2025‑01‑01: How I helped fix sleep-wake hangs on Linux with AMD GPUs.