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

• 2024‑12‑04: Inheritance was invented as a performance hack in Simula.
• 2024‑12‑04: The Hoare cube.
• 2024‑11‑30: Compilation on the GPU? A feasibility study.
• 2024‑11‑30: Combining git repos with josh-filter.
• 2024‑11‑29: Slow networking between cloud VMs on the same host.
• 2024‑11‑28: Wislist for Linux from the mold linker's POV.
• 2024‑11‑27: if constexpr requires requires { requires } in C++.
• 2024‑11‑27: Offpunk: an offline-first command-line web browser.
• 2024‑11‑27: Chawan: a web browser for your terminal.
• 2024‑11‑25: Theory-building and why employee churn is lethal to software companies.
• 2024‑11‑20: Map keys and lifetimes in Rust.
• 2024‑11‑20: How did software get so reliable without proof?
• 2024‑11‑20: Nominal types for storing, structural types for manipulating.
• 2024‑11‑11: Precise inference of expressive units of measurement types.
• 2024‑11‑11: Type inference for units of measure.
• 2024‑11‑10: Formalising graphs with coinduction in Agda.
• 2024‑11‑09: Texture-less GPU text rendering.
• 2024‑11‑09: Known attacks and a primer on elliptic curve cryptography.
• 2024‑11‑08: The main features of CPL. (1963)
• 2024‑11‑08: The mechanical evaluation of expressions: Landin on the lambda calculus. (1964)
• 2024‑11‑08: CPL: failed venture or noble ancestor?
• 2024‑11‑05: Resurrection: the journal of the Computer Conservation Society.
• 2024‑11‑05: The official Aztec C online museum.
• 2024‑11‑04: Macros, safety, and SOA (struct-of-arrays) in Rust.
• 2024‑11‑04: A Hamiltonian circuit for Rubik's Cube.
• 2024‑11‑04: C++, complexity, and compiler bugs.
• 2024‑11‑02: Why PostgreSQL pg_dump is amazing.
• 2024‑11‑01: Emacs org mode syntax cheat sheet.
• 2024‑11‑01: ActivityBot: a simple ActivityPub bot server in PHP.
• 2024‑10‑29: TCP SYN spoofing attack directs abuse complaints at Tor relays.
• 2024‑10‑28: OpenZFS deduplication is good now and you shouldn't use it.
• 2024‑10‑28: What’s new in POSIX 2024 XCU commands and utilities.
• 2024‑10‑27: A new git-repack algorithm shrunk Microsoft’s Javascript monorepo git size by 94%.
• 2024‑10‑24: Why write a new RTOS for CHERIoT?
• 2024‑10‑23: Adding row polymorphism to Damas-Hindley-Milner.
• 2024‑10‑22: Rustls outperforms OpenSSL and BoringSSL.
• 2024‑10‑22: A Mathematica interpreter in Typescript.
• 2024‑10‑22: On the problem of naming things.
• 2024‑10‑21: Learn Rust the dangerous way.
• 2024‑10‑20: Better defunctionalization through lambda set specialization.
• 2024‑10‑20: The origins of the term “daemon” in computing.
• 2024‑10‑18: superlinker: a tool for reinterpreting ELF executables and shared libraries.
• 2024‑10‑17: C89 draft standard in HTML.
• 2024‑10‑12: The road to OCIv2 images: what's wrong with tar?
• 2024‑10‑11: Quantifying the Kevin Bacon game: a statistical exploration of Hollywood’s most connected actors.
• 2024‑10‑09: SQLite's use of Tcl.
• 2024‑10‑08: Five times ICANN deleted a ccTLD, and what it means for .io
• 2024‑10‑08: The origins of PostScript.
• 2024‑10‑08: Tartufo searches through git repositories for high entropy strings and secrets.
• 2024‑10‑07: Big ball of mud: the de facto standard software architecture.
• 2024‑10‑07: Octothorpes: hashtags for the open Internet.
• 2024‑10‑06: The Gleam programming language is pragmatic.
• 2024‑10‑06: Playing with PostgreSQL and the BOLT linker layout optimizer.
• 2024‑10‑05: Towards standards for handwritten zero and oh: much ado about nothing (and a letter). (1967)
• 2024‑10‑04: "A=B", a book about computer methods of discovery and proof of hypergeometric identities.
• 2024‑10‑03: Terminal colours are tricky.
• 2024‑10‑02: Height hunt: a quest to find and visit every possible road vehicle height restriction sign in the UK.
• 2024‑10‑02: An introduction to the Filament hardware design language.
• 2024‑10‑01: The case of the missing increment: Golden Cove twice as fast as expected?!
• 2024‑09‑30: Beyond multi-core parallelism in Rust: faster Mandelbrot with SIMD.
• 2024‑09‑29: A p-adic representation of the rational numbers for fast easy arithmetic. (1979)
• 2024‑09‑27: Malicious SHA-1.
• 2024‑09‑26: Attacking UNIX systems via CUPS.
• 2024‑09‑25: A brief history of microprogramming.
• 2024‑09‑24: A few secure random bytes in PostgreSQL without pgcrypto.
• 2024‑09‑23: “Truly hygienic” let statements in Rust.
• 2024‑09‑21: Questioning the criteria for evaluating non-cryptographic hash functions.
• 2024‑09‑21: The working archivist's guide to enthusiast CD-ROM archiving tools.
• 2024‑09‑21: The lost language extensions of MetaWare's High C compiler.
• 2024‑09‑19: Digital signatures and how to avoid them.
• 2024‑09‑19: 20 years later, real-time Linux makes it to the mainline kernel.
• 2024‑09‑18: Use IDENTITY columns instead of SERIAL in PostgreSQL.
• 2024‑09‑18: Handling 8kHz raw mouse input on Windows.
• 2024‑09‑18: Bézier curve arc length parametrizations.
• 2024‑09‑17: Ratchets in software development.
• 2024‑09‑16: Ante: A low-level functional language with algebraic effects and safe shared mutability.
• 2024‑09‑15: Turning disposable vapes into a fast charge power bank.
• 2024‑09‑15: A time consuming vDSO pitfall for 32-bit code on arm64 Linux.
• 2024‑09‑14: Porting SBCL to the Nintendo Switch.
• 2024‑09‑12: smolweb HTML specification
• 2024‑09‑09: Debunking CISC vs RISC code density.
• 2024‑09‑09: A low-level look at A-normal form.
• 2024‑09‑06: Massachusetts Bodged Transistor Authority: How we turned MBTA Red Line equipment into a car speedometer.
• 2024‑09‑04: LSP: the good, the bad, and the ugly.
• 2024‑09‑03: Is this Rust trait sealed or not?
• 2024‑09‑03: Unmaking the Makefiles: exorcising the Rust compiler test suite one file at a time.
• 2024‑09‑01: A simple generic parallelism idiom and C++17 specifics.
• 2024‑09‑01: CHERIoT: a study in CHERI for RISC-V microcontrollers.
• 2024‑08‑31: Fortran dot/comma bug urban legend.
• 2024‑08‑29: Your immune system is not a muscle.
• 2024‑08‑29: Compiling JavaScript to Wasm: partial evaluation, weval, and the first Futamura projection.
• 2024‑08‑29: Air Con: pay $1697 for an on/off switch, or fix the Android controller tablet?
• 2024‑08‑29: Rate limiting, ATM cells, and GCRA.
• 2024‑08‑29: Time-series compression algorithms, explained.
• 2024‑08‑29: What every computer scientist should know about floating-point arithmetic.
• 2024‑08‑27: 5000x faster CRDTs: an adventure in optimization.
• 2024‑08‑27: MiniJinja: learnings from building a template engine in Rust.
• 2024‑08‑27: Should scientific fraud and research misconduct be illegal?
• 2024‑08‑27: Emulating x86 / amd64 on RISC-V.
• 2024‑08‑26: Poor foundations in geometric algebra.
• 2024‑08‑26: Writing a Rust compiler in C?!
• 2024‑08‑25: Linux pipes are slow.
• 2024‑08‑25: Old buildings in Cambridge.
• 2024‑08‑24: Printing the web: HTML and CSS for paper books.
• 2024‑08‑24: Geometric search trees.
• 2024‑08‑23: We need visual programming. No, not like that.
• 2024‑08‑23: Ted Dunning on histograms vs quantile sketches.
• 2024‑08‑18: How OCaml type checker works, or, what polymorphism and garbage collection have in common.
• 2024‑08‑18: The door problem: what does a game designer do?
• 2024‑08‑18: Techniques for safe garbage collection in Rust.
• 2024‑08‑14: Incremental TT munchers: perhaps the most powerful macro parsing technique in Rust macro_rules.
• 2024‑08‑14: The medieval 'New England': a forgotten Anglo-Saxon colony on the north-eastern Black Sea coast.
• 2024‑08‑14: Round in circles and back again: Max Roberts updated London Underground concentric circles and spokes map.
• 2024‑08‑13: Good retry, bad retry: an incident story.
• 2024‑08‑13: Division, modulus, and remainder for computer scientists.
• 2024‑08‑11: Rosie pattern language: modern text pattern matching to replace regex.
• 2024‑08‑10: Confusion attacks: exploiting hidden semantic ambiguity in Apache httpd.
• 2024‑08‑08: A better light source for scanning color negative film.
• 2024‑08‑07: A trilingual inscription at Behistun near Persepolis led to the decipherment of cuneiform.
• 2024‑08‑07: Situated software.
• 2024‑08‑04: Helmut Schmidt Future Prize acceptance speech by Meredith Whittaker.
• 2024‑08‑04: Git credential: password store integration for git-over-https
• 2024‑08‑03: Where do debuggers find shared library paths in core dumps?
• 2024‑08‑03: Primitive recursive functions for the working programmer.
• 2024‑08‑02: Another variable-length integer encoding.
• 2024‑08‑01: What your web framework never told you about SQL injection protection.
• 2024‑07‑31: Where does the name "algebraic data type" come from?
• 2024‑07‑30: Quint: An executable specification language with delightful tooling based on the temporal logic of actions (TLA).
• 2024‑07‑30: Calculating the cost of a Google Deepmind paper, or, how to burn $10,000,000 on an arXiv preprint.
• 2024‑07‑29: How to build highly-debuggable C++ binaries.
• 2024‑07‑27: Unsafe read beyond of death: optimized short string SIMD load.
• 2024‑07‑27: Counting bytes faster with SIMD, interleaving, and prefetching.
• 2024‑07‑26: CompilerFax: phone a compiler, fax it some code, it faxes back the results.
• 2024‑07‑26: Meta-Thunderbolt-Inception
• 2024‑07‑26: Rosemary Grant on the Galapagos finches: “Evolution happens much quicker than Darwin thought”.
• 2024‑07‑25: An extensive benchmark of C and C++ hash tables.
• 2024‑07‑22: Using algebra to refactor data types.
• 2024‑07‑21: How not to use box shadows.
• 2024‑07‑19: Concerns about passkeys.
• 2024‑07‑19: NSCopyObject, the griefer that keeps on griefing.
• 2024‑07‑19: The GNU make jobserver Implementation.
• 2024‑07‑18: Hash-based bisect debugging in compilers and runtimes.
• 2024‑07‑18: Why Polars rewrote its Arrow string data type.
• 2024‑07‑16: How the Stream Deck rose from the ashes of the legendary Optimus Maximus keyboard.
• 2024‑07‑15: Pull requests via `git push`.
• 2024‑07‑15: Objective tests for aphantasia.
• 2024‑07‑13: git-pr: A new git collaboration service.
• 2024‑07‑12: Nine rules for successful power meetings.
• 2024‑07‑12: Beating the cache with value speculation.
• 2024‑07‑12: That afternoon headache is a sign of stale air.
• 2024‑07‑12: Are you sure you want to use mmap() in your database management system?
• 2024‑07‑11: Hash maps that don’t hate you.
• 2024‑07‑11: First contact with SQLite.
• 2024‑07‑10: Towards reproducible rebuilds of Debian packages.
• 2024‑07‑09: Is prefix of string in table? A journey into SIMD string processing.
• 2024‑07‑08: On understanding data abstraction, revisited.
• 2024‑07‑06: Properly property testing concurrent data structures.
• 2024‑07‑04: The X window system at 40.
• 2024‑07‑04: xsum: exactly-rounded summation of floating point values.
• 2024‑07‑03: The sad state of property-based testing libraries.
• 2024‑07‑02: BusyBeaver(5) is now proved to be 47,176,870.
• 2024‑06‑29: POSIX 2024 changes.
• 2024‑06‑29: Bytecode breakdown: unraveling Factorio's Lua security flaws.
• 2024‑06‑29: A eulogy for DevOps.
• 2024‑06‑27: Valve.Computer: A modern 8 bit design, built using 1950s thermionic valves.
• 2024‑06‑26: Profiling with ctrl-C.
• 2024‑06‑25: Re-creating early generative art: Schotter, by Georg Nees.
• 2024‑06‑25: Sans I/O when the rubber meets the road.
• 2024‑06‑25: Network protocols, sans I/O.
• 2024‑06‑24: ChocoPy: a subset of Python 3 for teaching compiler construction.
• 2024‑06‑24: Resolving metastability issues during bootstrapping CLOS.
• 2024‑06‑23: How to design a CPU ISA (instruction set architecture).
• 2024‑06‑23: Why is AVX 512 useful for the RPCS3 PlayStation 3 emulator?
• 2024‑06‑23: A history of Psion and Symbian.
• 2024‑06‑22: Optimizing SQLite for servers.
• 2024‑06‑22: The simple essence of algebraic subtyping: principal type inference with subtyping made easy.
• 2024‑06‑21: 1/25-scale Cray C90 wristwatch.
• 2024‑06‑21: Reflections on software performance.
• 2024‑06‑20: How to use the new counted_by attribute in C and Linux.
• 2024‑06‑20: Avoiding the top 10 NGINX configuration mistakes.
• 2024‑06‑20: Public JavaScript CDNs are useless and dangerous.
• 2024‑06‑20: The full-source bootstrap: building from source all the way down.
• 2024‑06‑19: Demystifying Rust's ? operator and Try trait.
• 2024‑06‑18: Peak population projections.
• 2024‑06‑18: Avoiding Emacs bankruptcy.
• 2024‑06‑18: Equality has more than one meaning in mathematics.
• 2024‑06‑17: Zig-style generics are not well-suited for most languages.
• 2024‑06‑17: Making robots plan faster with SIMD and Rust.
• 2024‑06‑17: The ineffable types of Rust: how to make self-borrows safe.
• 2024‑06‑16: MicroMac, a 128k Macintosh emulated on an RP2040.
• 2024‑06‑16: There are only three frequencies: never, sometimes, always.
• 2024‑06‑16: Stupid TLS facts: session resumption.
• 2024‑06‑16: Reconstructing public keys from cryptographic signatures.
• 2024‑06‑16: The story of reformatting 100k source files at Google in 2011.
• 2024‑06‑15: Exponentially better rotations.
• 2024‑06‑13: Whose CIDR is it anyway? Scanning all of whois and rdap.
• 2024‑06‑13: Chaos in the medium: watercolour plotting.
• 2024‑06‑12: Bamboo can be as invasive as Japanese knotweed.
• 2024‑06‑12: Inside Mexico’s anti-avocado militias.
• 2024‑06‑11: Forsp: a Forth+Lisp hybrid CBPV language.
• 2024‑06‑10: Dangers of newlines in inline assembly.
• 2024‑06‑09: Using HDMI EMI for fast wireless data transfer.
• 2024‑06‑09: A (draft) taxonomy of SIMD usage.
• 2024‑06‑08: Towards federated key transparency.
• 2024‑06‑08: A fast alternative to the modulo reduction.
• 2024‑06‑08: Fibonacci hashing: the optimization that the world forgot (or: a better alternative to integer modulo).
• 2024‑06‑08: Compilers are (too) smart: a failed popcount optimization.
• 2024‑06‑07: What is PID 0?
• 2024‑06‑07: Leveraging Zig's allocators.
• 2024‑06‑07: Tom7’s BoVeX typesetter with AI-assisted justified text.
• 2024‑06‑07: Speeding up rustc by being lazy.
• 2024‑06‑06: lelwel: a resilient LL(1) parser generator for Rust.
• 2024‑06‑06: let rand = main as usize;
• 2024‑06‑06: Shortcat: Manipulate macOS masterfully, minus the mouse.
• 2024‑06‑06: First steps with DHCPv6-PD on OpenBSD.
• 2024‑06‑06: Propagating bounds through bitwise operations in abstract interpretation.
• 2024‑06‑04: Simple proofs with Z3Py.
• 2024‑06‑04: Why do electronic components have such odd values? Renard numbers and ISO 3.
• 2024‑06‑04: Cloning-based context-sensitive pointer alias analysis using binary decision diagrams in bddbddb.
• 2024‑06‑04: bddbddb: using Datalog with binary decision diagrams for program analysis.
• 2024‑06‑04: Sound, precise, and fast abstract interpretation with tristate numbers.
• 2024‑06‑04: Bit-twiddling abstract addition with unknown bits.
• 2024‑06‑04: LL and LR in context: why parsing tools are hard.
• 2024‑06‑04: automemcpy: a framework for automatic generation of fundamental memory operations.
• 2024‑06‑02: Tiny Tapeout: an educational project to get your designs manufactured on a real chip.
• 2024‑06‑02: Tock: an embedded operating system in Rust.
• 2024‑06‑02: The borrow checker within Rust.
• 2024‑06‑02: Rust and dynamically-sized thin pointers.
• 2024‑06‑01: Rust regex engine internals as a library.
• 2024‑06‑01: Performance culture.
• 2024‑06‑01: X is justifiably slow?
• 2024‑06‑01: Electromagnetic linear clock.
• 2024‑05‑31: The greatest clock (and map) ever made.
• 2024‑05‑30: Ultrasonic cold brew coffee.
• 2024‑05‑30: Why, after 6 years, I’m over GraphQL.
• 2024‑05‑29: Recycling steel with cement in an arc furnace could produce zero-emissions concrete.
• 2024‑05‑29: Why rejecting invalid XML in the browser is a bad idea.
• 2024‑05‑28: A study of MAC address randomization in mobile devices and when it fails.
• 2024‑05‑28: Surveilling the masses with Wi-Fi-based positioning systems.
• 2024‑05‑28: I’ve womansplained him to death.
• 2024‑05‑28: The Cephes mathematical library.
• 2024‑05‑28: IPv6 link-local stunts: ping ff02::1 etc.
• 2024‑05‑28: Programming pearls: Bumper sticker computer science.
• 2024‑05‑28: Why software projects take longer than you think: a statistical model.
• 2024‑05‑28: Doing is normally distributed, learning is log-normal.
• 2024‑05‑28: Wasmi WebAssembly interpreter’s new execution engine.
• 2024‑05‑27: Reclaiming IPv4 Class E 240.0.0.0/4.
• 2024‑05‑26: Statically typed functional programming with Python 3.12.
• 2024‑05‑26: RuSSH: a Rust SSH client and server library.
• 2024‑05‑26: Taming floating-point sums with Rust.
• 2024‑05‑21: vu128: Efficient variable-length integers
• 2024‑05‑21: Rust's iterators optimize nicely—and contain a footgun.
• 2024‑05‑19: I am too old to create a popular programming language.
• 2024‑05‑19: How often is the wife taller than the husband?
• 2024‑05‑19: AOT JS compilation by wevaling the wasms.
• 2024‑05‑19: Compilers for free with weval, a wasm partial evaluator.
• 2024‑05‑19: VirusTotal YARA has been rewritten in Rust as YARA-X.
• 2024‑05‑18: Why writing correct software is hard.
• 2024‑05‑18: Fix your video game’s timestep!
• 2024‑05‑18: Fixing iterative damping interpolation in video games.
• 2024‑05‑18: TCP performance and the Mathis equation.
• 2024‑05‑18: Practical third-party library sandboxing with RLBox.
• 2024‑05‑17: Golang disables Nagle’s algorithm, making it evil on shitty networks.
• 2024‑05‑17: A transport protocol's view of Starlink.
• 2024‑05‑17: What even is a pidfd anyway?
• 2024‑05‑16: History of the Italian electrical system.
• 2024‑05‑16: A look at the Mojo language for bioinformatics.
• 2024‑05‑16: Strings in Julia vs Rust: you probably don't need to validate UTF-8.
• 2024‑05‑16: D3 in depth.
• 2024‑05‑16: Understanding misunderstandings in C source code using IOCCC winners.
• 2024‑05‑16: Ebury is alive but unseen: 400k Linux servers compromised by the Windigo group.
• 2024‑05‑16: Some notes on Rust, mutable aliasing, and formal verification.
• 2024‑05‑15: A tale of two sieves.
• 2024‑05‑15: The creator of Magic: The Gathering knows exactly where it all went wrong.
• 2024‑05‑14: Optimizing the Roc parser/compiler with data-oriented design.
• 2024‑05‑14: A triad of factors that explain the nature of software.
• 2024‑05‑13: Submitting a Linux kernel patch with b4.
• 2024‑05‑13: Exploring GNU C extensions in the Linux kernel.
• 2024‑05‑13: Parsing JSON is a minefield.
• 2024‑05‑12: The alternative programming language implementation problem.
• 2024‑05‑12: GPUs go brrr: how to keep the nVIDIA H100 tensor cores fed.
• 2024‑05‑12: Functional semantics in imperative clothing in the Roc programming language.
• 2024‑05‑12: Can we make bicycle manufacturing sustainable again?
• 2024‑05‑12: Emoji history: the missing years.
• 2024‑05‑12: Garbage collectors are scary.
• 2024‑05‑12: Breaking DKIM and BIMI in 2024 using the Debian OpenSSL bug CVE-2008-0166.
• 2024‑05‑11: In Rust, methods should be object safe.
• 2024‑05‑11: Why the CORDIC algorithm lives rent-free in my head.
• 2024‑05‑11: Thread: the wireless tech we can't use or teach.
• 2024‑05‑09: It's always TCP_NODELAY. Every damn time.
• 2024‑05‑09: Rust through the ages.
• 2024‑05‑09: Scanners work fine over iSCSI.
• 2024‑05‑09: Needle: a DFA regex library that compiles to JVM bytecode.
• 2024‑05‑09: The await event horizon in JavaScript.
• 2024‑05‑08: B612: the Airbus cockpit display font.
• 2024‑05‑08: The C preprocessor iceberg.
• 2024‑05‑07: Secure Randomness in Golang 1.22.
• 2024‑05‑07: Search has been put in the vibe space.
• 2024‑05‑06: JTAG hacking with a Raspberry Pi: introducing the PiFex.
• 2024‑05‑06: How to successfully rewrite a C++ codebase in Rust.
• 2024‑05‑06: Decoding UTF8 with the pext parallel extract instruction.
• 2024‑05‑06: The C++ iceberg.
• 2024‑05‑05: An extended subtweet on power-over, vs power-with or power-to.
• 2024‑05‑05: The Italian streets that don't exist on any map.
• 2024‑05‑05: Thinking is bad: implications of human error research for spreadsheet research and practice.
• 2024‑05‑05: How to build a $20 billion semiconductor fab.
• 2024‑05‑05: Byte magazine August 1983: The C Language.
• 2024‑05‑05: Bit-stealing made legal: compilation for custom memory representations of algebraic data types.
• 2024‑05‑05: TypeID: type-safe, K-sortable, globally unique identifiers.
• 2024‑05‑05: Understanding Stein's paradox in higher-dimensional statistics.
• 2024‑05‑03: ECDH-OMR: elliptic curve Diffie-Hellman oblivious message retrieval.
• 2024‑05‑02: Hobby’s algorithm for aesthetic Bézier splines.
• 2024‑05‑02: Piccolo: a stackless Lua interpreter in Rust.
• 2024‑05‑02: TestResult: a Rust error type that panics early.
• 2024‑05‑02: Unwind considered harmful?
• 2024‑05‑02: The world's loudest Lisp program, for tunnel evacuation.
• 2024‑05‑02: PaperWM.spoon: tiled scrollable window manager for Hammerspoon on MacOS.
• 2024‑05‑01: It's time to stop recommending Clean Code.
• 2024‑04‑30: Rink: an open source unit-aware calculator.
• 2024‑04‑30: iRRAM: exact arithmetic in C++.
• 2024‑04‑30: PostgreSQL supported platforms over time.
• 2024‑04‑30: Bytecode VMs in surprising places.
• 2024‑04‑30: PowerShell monad manifesto.
• 2024‑04‑30: State of the terminal.
• 2024‑04‑29: So, you want to write an unsafe crate in Rust?
• 2024‑04‑29: The space bar stabilizer problem.
• 2024‑04‑29: FreeBee: AT&T 3B1 UNIX PC emulator.
• 2024‑04‑29: Bloat busters: pg_repack vs pg_squeeze.
• 2024‑04‑29: Importing ECMAscript modules with require() in node.js.
• 2024‑04‑28: The invention of the integrated circuit recorded in Jean Hoerni's patent notebook.
• 2024‑04‑28: Synth wars: The story of MIDI, the one interface that ruled them all.
• 2024‑04‑28: Building an IBM 3270 terminal controller.
• 2024‑04‑27: Tasks are the wrong abstraction for async Rust.
• 2024‑04‑26: Captain Zilog crushed! The story of the Z8000.
• 2024‑04‑26: Passkeys: a shattered dream.
• 2024‑04‑25: The weird world of Windows file paths.
• 2024‑04‑24: How web bloat impacts users with slow devices.
• 2024‑04‑24: So you want to learn to break ciphers?
• 2024‑04‑24: Digitized continuous magnetic recordings of the Carrington event from Greenwich and Kew.
• 2024‑04‑23: Inside the Super Nintendo cartridges.
• 2024‑04‑23: The bubble sort curve.
• 2024‑04‑23: No one buys books.
• 2024‑04‑22: Manual for Larry Tesler’s PUB markup language. (1971)
• 2024‑04‑19: A history of parsers of the Ruby programming language.
• 2024‑04‑19: Cable maintenance ships: The invisible seafaring industry that keeps the internet afloat.
• 2024‑04‑19: Raw flux streams and obscure formats: Further work around imaging 5.25-inch floppy disks.
• 2024‑04‑18: Formal methods: just good engineering practice?
• 2024‑04‑18: A domino computer.
• 2024‑04‑17: Feathers are one of evolution’s cleverest inventions.
• 2024‑04‑17: Will we have a negative leap second?
• 2024‑04‑17: The hardest problem in web design: centering things.
• 2024‑04‑16: Some useful types for database-using Rust web apps.
• 2024‑04‑16: Etak Navigator: how they made a mapping computer in the 1980s.
• 2024‑04‑15: Five little languages and how they grew: Dennis Ritchie’s talk at HOPL on the history of C.
• 2024‑04‑14: Sandboxing all the things with Flatpak and BubbleBox.
• 2024‑04‑14: sotrace: show hidden dependencies in Linux binaries.
• 2024‑04‑11: The simple beauty of XOR floating point time series compression.
• 2024‑04‑11: A simple derivation of sin and cos by stacking triangles.
• 2024‑04‑10: BatBadBut: You can't securely execute commands on Windows.
• 2024‑04‑09: Halbach magnetic array.
• 2024‑04‑09: The link between abortion and crime.
• 2024‑04‑09: path.join considered harmful, or openat() all the things.
• 2024‑04‑09: An introduction to jump threading optimizations in gcc.
• 2024‑04‑09: Concurrency vs paralellism.
• 2024‑04‑09: The server chose violence: error handling in the Hubris embedded OS.
• 2024‑04‑08: It's time for operating systems to rediscover hardware.
• 2024‑04‑08: Putting out the hardware dumpster fire.
• 2024‑04‑05: The state of time in Rust: leaps and bounds.
• 2024‑04‑05: Features I wish PostgreSQL had as a developer.
• 2024‑04‑05: The case against self-closing tags in HTML.
• 2024‑04‑05: Switching to the meow modal editing system from evil emacs.
• 2024‑04‑04: Conway's Game of Life through time.
• 2024‑04‑04: HTTP/2 CONTINUATION flood denial of service vulnerability.
• 2024‑04‑04: Putting an xz backdoor payload in a valid RSA key.
• 2024‑04‑03: Cowgol: an experimental, Ada-inspired language for 8 bit micros.
• 2024‑04‑03: Diff modulo base, for comparing rebased branches.
• 2024‑04‑03: Multiple cursors for emacs.
• 2024‑04‑01: The Wi-Fi only works when it's raining?!
• 2024‑04‑01: When concurrency matters: behaviour-oriented concurrency.
• 2024‑04‑01: The muscular imagination of Iain M. Banks: a future you might actually want to live in.
• 2024‑03‑31: A kinematically coupled piezo nanometer-resolution microscope focus stage.
• 2024‑03‑31: Countering trusting trust.
• 2024‑03‑31: A systematic analysis of the Juniper Dual EC DRBG backdoor.
• 2024‑03‑30: Basic things to support your software project.
• 2024‑03‑30: The "not rocket science" rule of continuous integration (and the story of monotone and bors).
• 2024‑03‑30: Xz format inadequate for long-term archiving.
• 2024‑03‑29: A new provisioning tool built with mgmt.
• 2024‑03‑28: TCP is an underspecified two-node consensus algorithm and what that means for your proxies.
• 2024‑03‑28: Binary Fuse Filters: fast and smaller than xor filters.
• 2024‑03‑26: Preventing cross-service UDP loops in QUIC.
• 2024‑03‑25: Interval parsing grammars for file format parsing.
• 2024‑03‑23: Unexplanations: SQL is syntactic sugar for relational algebra. (not!)
• 2024‑03‑21: Progressing towards the redefinition of the second based on an optical frequency standard.
• 2024‑03‑21: A giant leap for the leap second. Is humankind ready?
• 2024‑03‑19: The invention of fuzz testing.
• 2024‑03‑15: JESK56: a diodeless keyboard matrix derived using graph theory.
• 2024‑03‑13: Mu-Ency: the encyclopedia of the Mandelbrot set.
• 2024‑03‑12: Identifying software: supply chain security with GNU Guix.
• 2024‑03‑12: yet-another-cad-viewer: display OCP/CadQuery/Build123d models in a web browser.
• 2024‑03‑11: Staged generic programming.
• 2024‑03‑10: Do Be Do Be Do, or, Frank: a strict functional programming language with algebraic effects.
• 2024‑03‑10: Compiling without continuations.
• 2024‑03‑10: Kinds are calling conventions.
• 2024‑03‑09: Call-by-push-value: decomposing call-by-value and call-by-name.
• 2024‑03‑09: Call-by-push-value. (1999)
• 2024‑03‑09: I'm betting on call-by-push-value.
• 2024‑03‑09: SuperC: parsing all of C by taming the preprocessor.
• 2024‑03‑09: The SuperC parsing framework.
• 2024‑03‑08: USAF computer security technology planning study: memory safety bugs in 1972.
• 2024‑03‑07: CAP twelve years later: how the "rules" have changed.
• 2024‑03‑07: The CAP theorem: the bad, the bad, and the ugly.
• 2024‑03‑06: Conway’s Law: the only unbreakable law.
• 2024‑03‑05: The "missing" graph datatype already exists. It was invented in the 1970s: relational algebra and datalog.
• 2024‑03‑05: Behind F1's velvet curtain.
• 2024‑03‑04: The hunt for the missing graph data type.
• 2024‑03‑04: Migrating from Emacs lsp-mode to Eglot.
• 2024‑03‑04: Motion blur all the way down.
• 2024‑03‑04: Kubernetes failure stories.
• 2024‑03‑03: The case against geometric algebra.
• 2024‑03‑03: 50 years ago: the new Cambridge University Press printing house.
• 2024‑02‑26: Tracing the baseband: cellphone modems.
• 2024‑02‑26: What is the "God Mode" folder in Windows 10, and how do I enable it?
• 2024‑02‑25: Beware of -ffast-math and -Ofast.
• 2024‑02‑24: Really large git repositories.
• 2024‑02‑22: A security kernel based on the lambda calculus.
• 2024‑02‑18: Ten Python datetime pitfalls, and what libraries are (not) doing about it.
• 2024‑02‑18: Smoothed asymptotics: from number theory to quantum field theory.
• 2024‑02‑14: Thomas Rokicki’s survey of algorithms for Conway’s Game of Life.
• 2024‑02‑13: Conway's Game of Life is omniperiodic.
• 2024‑02‑07: jj init : an introduction to the jujutsu version control system.
• 2024‑02‑06: RCL: A reasonable configuration language.
• 2024‑02‑03: Pkl: a programming language for configuration.
• 2024‑01‑29: __VA_OPT__ minutiae.
• 2024‑01‑29: Recursive macros with C++20 __VA_OPT__.
• 2024‑01‑17: Passing nothing is surprisingly difficult: empty slices in C, C++, and Rust.
• 2024‑01‑15: MULTIPLY: the Francis Hookham collection of hand held electronic calculators.
• 2024‑01‑15: When random isn't.
• 2024‑01‑14: QMK and keyboards.
• 2024‑01‑08: niri: A scrollable-tiling Wayland compositor.
• 2024‑01‑08: How to stop Linux threads cleanly.
• 2024‑01‑06: Vectrex reborn: How a chance encounter gave new life to a dead console.
• 2024‑01‑05: Speed up your code: don't pass structs bigger than 16 bytes on AMD64.
• 2024‑01‑04: Golang: what we got right, what we got wrong.
• 2024‑01‑04: An overview of the Starlark programming language.
• 2024‑01‑03: Spatial Shell: a window layout assistant for i3 and sway.
• 2024‑01‑03: newm-atha: a touchpad and touchscreen centric wayland compositor.
• 2024‑01‑03: SIEVE is simpler than LRU.
• 2024‑01‑02: What I've learned about flow fields for generative art.
• 2024‑01‑02: A CAP tradeoff in Kubernetes.
• 2023‑12‑30: Git commit signing is kinda wack.
• 2023‑12‑27: A national evil: how iodized salt banished the curse of the goitre from Switzerland.
• 2023‑12‑26: What is a parser mismatch vulnerability?
• 2023‑12‑26: Lotus 1-2-3 for Linux.
• 2023‑12‑26: Reptar: an Intel x86 microcode bug.
• 2023‑12‑21: How to find secure hash collisions.
• 2023‑12‑16: Why aren't we SIEVE-ing? A new cache eviction algorithm.
• 2023‑12‑15: Forcy McForceFace: building a keyboard switch force tester out of an old 3D printer.
• 2023‑12‑13: Unauthenticated Bluetooth keystroke-injection in Android, Linux, macOS, and iOS.
• 2023‑12‑11: Compiling to categories.
• 2023‑12‑11: Cutting out continuations.
• 2023‑12‑10: Lambda to SKI, semantically.
• 2023‑12‑08: A brief history of keyboard encoding.
• 2023‑12‑05: A branchless quicksort partition algorithm.
• 2023‑12‑05: Stop stealing sheep, and find out how typography works.
• 2023‑12‑04: You don't need JavaScript for that.
• 2023‑11‑29: Why is Rust slower to read a file than Python?
• 2023‑11‑29: Destructing trees safely and cheaply.
• 2023‑11‑28: It's About Time! Accurate clocks in distributed systems.
• 2023‑11‑27: The largest number representable in 64 bits.
• 2023‑11‑24: FullControl: unconstrained gcode design for 3D printers.
• 2023‑11‑23: Wasmtime and Cranelift in 2023.
• 2023‑11‑23: Commercial flights driven off course by GPS spoofing attacks.
• 2023‑11‑22: Why does the moon change size when you snipe it in GTA?
• 2023‑11‑21: How I (kind of) killed Mercurial at Mozilla.
• 2023‑11‑21: Lessons from METAFONT.
• 2023‑11‑21: Drawing diagrams for TeX with MetaPost.
• 2023‑11‑20: A close encounter with false sharing in Rust.
• 2023‑11‑20: Friends don't let friends make bad graphs.
• 2023‑11‑20: setenv() is not thread safe and C doesn't want to fix it.
• 2023‑11‑19: Checking Rust crate semver stability in the presence of doc(hidden) items.
• 2023‑11‑17: Oops! We Automated Bullshit.
• 2023‑11‑17: Why you need a "WTF notebook".
• 2023‑11‑16: Can your static type system handle linear algebra?
• 2023‑11‑16: We don’t do DST at this company.
• 2023‑11‑16: A subtle Python SIGPIPE bug.
• 2023‑11‑15: Popcount walks: next, previous, toward and nearest.
• 2023‑11‑14: Let’s be real about dependencies.
• 2023‑11‑14: Replacing HLS/DASH with Media over QUIC.
• 2023‑11‑13: 37 is the median value for the second prime factor of an integer.
• 2023‑11‑12: A quick look at register allocation with destination-driven code generation.
• 2023‑11‑12: Space Invaders street art mosaics.
• 2023‑11‑09: Interesting JavaScript bugs caught by no-constant-binary-expression in ESLint.
• 2023‑11‑07: Can solar and wind power Britain? An update of David MacKay’s numbers.
• 2023‑11‑07: Jezebel and the question of women’s anger.
• 2023‑11‑05: A proposed fix for C/C++ relaxed atomics in practice.
• 2023‑11‑03: Avoiding fallback and cold paths.
• 2023‑10‑23: Y2038: why Steam started picking a random font.
• 2023‑10‑23: Protomaps: an open source map of the world, deployable as a single static file.
• 2023‑10‑21: The not-so-glamourous origins of standard railway track gauge.
• 2023‑10‑21: Analyzing data 180,000x faster with Rust.
• 2023‑10‑20: How to mitigate the Hetzner/Linode XMPP.ru MitM attack.
• 2023‑10‑20: TLS MITM attack against a Russian XMPP / Jabber service.
• 2023‑10‑20: ANSI terminal security in 2023 and finding 10 CVEs.
• 2023‑10‑19: Stop your (business rules) engines!
• 2023‑10‑19: The road to hell is paved with good intentions and C++ modules.
• 2023‑10‑17: Higher quality random floats.
• 2023‑10‑15: Faster compile times from simpler dependency graphs in Rust.
• 2023‑10‑14: Open Props: sub-atomic CSS.
• 2023‑10‑13: Thumb calendar.
• 2023‑10‑13: Conical Slicing: A different angle of 3D printing.
• 2023‑10‑10: Text showdown: gap buffers vs ropes.
• 2023‑10‑10: ECC RAM on AMD Ryzen 7000 desktop CPUs.
• 2023‑10‑09: UK postal address oddities.
• 2023‑10‑05: ROCkN: Providing GPS-quality timing accuracy with portable optical atomic clocks.
• 2023‑10‑05: Report ITU-R TF.2511-0 (10/2022): Content and structure of time signals to be disseminated by radiocommunication systems and various aspects of current and potential future reference time scales, including their impacts and applications in radiocommunication.
• 2023‑10‑05: The Terminal Escapes: Engineering unexpected execution from command line interfaces.
• 2023‑10‑03: The 300% production problem.
• 2023‑10‑03: x86 amd64 SIMD instruction list: SSE to AVX512.
• 2023‑10‑03: Arm64 SIMD instruction list: SVE instructions.
• 2023‑10‑02: The Marvin attack: Bleichenbacher returns, again.
• 2023‑09‑29: Who really invented the alphabet?
• 2023‑09‑29: A plot of all objects in the universe.
• 2023‑09‑27: ARM LDM and STM are Turing complete.
• 2023‑09‑25: The invisible problem with editing text on phones.
• 2023‑09‑24: Introducing geometric algebra to software developers: a computational thinking approach.
• 2023‑09‑23: Polonius revisited, part 1.
• 2023‑09‑21: Speeding up the JavaScript ecosystem: polyfills gone rogue.
• 2023‑09‑19: Making Gaussian Splats smaller.
• 2023‑09‑19: EPDiy: an ESP32-based driver board for e-Paper / E-ink displays.
• 2023‑09‑18: Oglaf search index.
• 2023‑09‑18: Resilient LL parsing tutorial.
• 2023‑09‑14: Pagefind and URL search parameters.
• 2023‑09‑13: George Gorton Machine Co engraver typefaces.
• 2023‑09‑12: Hacking the Book8088 for better accuracy.
• 2023‑09‑12: What’s the smallest variety of CHERI?
• 2023‑09‑11: HDMI ISA graphics card for vintage PCs by improving the Graphics Gremlin.
• 2023‑09‑11: Pure Wasm Life 2: optimizing webassembly and canvas with WebGL.
• 2023‑09‑11: The Carrington Event of 1859 disrupted telegraph lines. A “Miyake Event” would be far worse.
• 2023‑09‑10: Adding Wi-Fi to the Macintosh Portable.
• 2023‑09‑09: Black-box concurrent data structures for NUMA architectures.
• 2023‑09‑09: Good performance is not just big O.
• 2023‑09‑02: Spoofing certificates with MD5 collisions in 2022.
• 2023‑09‑01: A deep dive into Single Pair Ethernet.
• 2023‑08‑31: Ad-hoc polymorphism erodes type-safety.
• 2023‑08‑31: Co-dfns versus BQN's implementation.
• 2023‑08‑31: The mystery of the Bloomfield bridge.
• 2023‑08‑29: Grave flaws in BGP error handling.
• 2023‑08‑26: I made a Typewriter out of Drums!
• 2023‑08‑24: FreeBSD on Firecracker.
• 2023‑08‑23: ROMRAM: using QSPI RAM with RP2040's SSI in read-write mode.
• 2023‑08‑23: USB HID device class definition.
• 2023‑08‑23: USB HID usage tables.
• 2023‑08‑22: Building and customizing a Kyria wireless ergonomic keyboard.
• 2023‑08‑21: Designing a PCB for the RP2040 Microcontroller | Microcontroller Tutorials
• 2023‑08‑21: Normal incidents.
• 2023‑08‑18: PolymurHash: a 64 bit universal hash function.
• 2023‑08‑13: Symmetry in Chaos.
• 2023‑08‑13: Virtualizing uxn.
• 2023‑08‑07: Reverse Z in 3D graphics (and why it’s so awesome).
• 2023‑08‑06: Why does libvirt support only 14 hot-plugged PCIe devices on x86-64?
• 2023‑08‑04: The physics of readable code.
• 2023‑08‑02: Why Python is terrible.
• 2023‑08‑02: Akin's laws of spacecraft design.
• 2023‑08‑02: MIT engineers create an energy-storing supercapacitor from cement and carbon black.
• 2023‑07‑31: The Fibonacci matrix.
• 2023‑07‑31: What John von Neumann really did at Los Alamos.
• 2023‑07‑30: Workarounds for C11 _Generic().
• 2023‑07‑29: LPython: novel, fast, retargetable Python compiler.
• 2023‑07‑22: Managing kitchen fruit flies with a Little Shop of Horrors.
• 2023‑07‑21: HP-1973: an HP calculator emulator.
• 2023‑07‑19: Local async executors should be the default in Rust.
• 2023‑07‑17: Appreciating RFC 8927 JSON type definition.
• 2023‑07‑16: Penrose: create beautiful diagrams by typing notation in plain text.
• 2023‑07‑11: salty: Ed25519 for ARM microcontrollers.
• 2023‑06‑26: Ideal dimensions for PCB breakaway tabs.
• 2023‑06‑24: No vehicles in the park: a game about content moderation.
• 2023‑06‑22: 57 different scripts descended from Egyptian hieroglyphs.
• 2023‑06‑09: Monongahela: a design for a balanced ternary computer.
• 2023‑06‑06: Wiio's laws of human communication
• 2023‑06‑04: BRR: A new line drawing method for the cycle savvy.
• 2023‑06‑04: Calculating position from raw GPS data.
• 2023‑05‑31: Hacking my “smart” toothbrush.
• 2023‑05‑30: Futex-likes on non-Linux systems.
• 2023‑05‑29: ITU News Magazine: The future of Coordinated Universal Time.
• 2023‑05‑29: SectorC: A C Compiler in 512 bytes.
• 2023‑05‑28: Bcrypt at 25: a retrospective on password security.
• 2023‑05‑23: Unpacking 5 billion varints in only 4 billion CPU cycles.
• 2023‑05‑22: Wrench: an embedded interpreter.
• 2023‑05‑19: bilge: a bit fiddling proc macro for Rust.
• 2023‑05‑17: Logs said it was DNS, it looked like DNS, it had to be DNS, it wasn't DNS.
• 2023‑05‑14: rxv6: a Rust rewrite of MIT’S xv6 teaching OS.
• 2023‑05‑13: Building a baseline JIT for Lua automatically.
• 2023‑05‑12: PS-HTTP: a web server written in PostScript.
• 2023‑05‑11: Building an anycast secondary DNS service.
• 2023‑05‑11: Building the Micro Mirror free software CDN.
• 2023‑05‑10: Semantics and scheduling for machine knitting compilers.
• 2023‑05‑08: On custom-width integer types.
• 2023‑05‑07: Mysteries of the Griffin iMate and the Apple Extended Keyboard II.
• 2023‑05‑07: The tale of -mrtd in GCC and Clang.
• 2023‑05‑07: Prolly trees: Merklizing the key/value store for fun and profit.
• 2023‑05‑07: On numbering hegemonies and namespace monopolies.
• 2023‑05‑03: I want to talk about WebGPU.
• 2023‑05‑02: Flattening ASTs with arena allocation.
• 2023‑05‑01: A mirror for Rust: compile-time reflection.
• 2023‑05‑01: First clean water, now clean air.
• 2023‑04‑30: Basics of space flight: orbital mechanics.
• 2023‑04‑29: gefs: a good enough filesystem for Plan 9.
• 2023‑04‑26: You could have invented futexes.
• 2023‑04‑22: The magic of DC-DC voltage conversion.
• 2023‑04‑22: Escheresque parquet deformations of an aperiodic monotile.
• 2023‑04‑21: n2: an alternative ninja implemrntation in Rust.
• 2023‑04‑16: The time Bell Labs brought the Statue of Liberty under its roof (literally).
• 2023‑04‑16: Registration desk process engineering at a furry convention.
• 2023‑04‑13: Mac keyboard layout configuration with hidutil.
• 2023‑04‑10: Night of the living brain fog, or how I hacked my sleep apnea better thanks to open source software.
• 2023‑04‑10: Can you trust a compiler to optimize (even vectorize) your code?
• 2023‑04‑10: nsss: a secure NSS-like implementation for static linking.
• 2023‑04‑10: Using RP2040 PIO to drive a poorly-designed display.
• 2023‑04‑09: Modular errors in Rust.
• 2023‑04‑08: Database “sharding” came from Ultima Online?
• 2023‑04‑07: The longest straight line in Great Britain (without crossing a public road).
• 2023‑04‑06: CAN Injection: keyless car theft.
• 2023‑03‑30: Mozilla XUL layout is gone from Firefox.
• 2023‑03‑15: No more DSLs: Implement and deploy a distributed system with a single program.
• 2023‑03‑14: Generating aerial imagery with your iPhone’s LiDAR sensor.
• 2023‑03‑12: How we knew space is a vacuum.
• 2023‑03‑10: \Device\Afd: what makes async Rust and libuv work on Windows.
• 2023‑03‑09: The Quest for Netflix on Asahi Linux.
• 2023‑03‑08: The linguistic registers of Rust.
• 2023‑03‑08: Historical notes on computer word and byte sizes.
• 2023‑03‑08: How Discord stores trillions of messages.
• 2023‑03‑07: How UC Davis medical school became remarkably diverse.
• 2023‑03‑03: Atkinson hyperlegible font.
• 2023‑02‑28: HOTscript: higher-order TypeScript, a library for type-level madness.
• 2023‑02‑05: Where is the most densely populated square kilometre in the UK?
• 2023‑02‑03: Weird things I learned while writing an x86 emulator.
• 2023‑01‑31: Adding comments to your static blog with Mastodon.
• 2023‑01‑30: Coloring for colorblindness.
• 2023‑01‑29: The 12-bit rainbow palette.
• 2023‑01‑28: C needs a new type qualifier: it’s time for null pointer safety.
• 2023‑01‑27: Netheads vs. bellheads redux: the strange victory of SIP over the telephone network.
• 2023‑01‑27: Reverse engineering the original Lytro lightfield camera.
• 2023‑01‑26: What time is it on the Moon?
• 2023‑01‑25: Do not taunt happy fun branch predictor.
• 2023‑01‑24: Bounded flexible arrays in C.
• 2023‑01‑18: XLR V3: Guinness world record holder for fastest quadcopter drone.
• 2023‑01‑08: User-level implementations of RCU (read copy update).
• 2023‑01‑08: The DIY scientist, the olympian, and the mutated gene.
• 2023‑01‑08: Production Twitter on one machine?
• 2023‑01‑05: Reflecting on transducers in Scheme.
• 2023‑01‑01: How to get Xfinity Stream to work on Linux: a tale of Widevine, Chrome OS, and a patched glibc.
• 2023‑01‑01: Better binary search in Haskell.
• 2022‑12‑27: Reasons to ditch LastPass.
• 2022‑12‑26: Verifying concurrent memory reclamation algorithms with grace.
• 2022‑12‑26: Hyaline: snapshot-free, transparent, and robust memory reclamation for lock-free data structures.
• 2022‑12‑26: NBR: neutralization based reclamation.
• 2022‑12‑21: Deriving a bit-twiddling hack: signed integer overflow.
• 2022‑12‑20: How to draw ugly lines really fast.
• 2022‑12‑12: The golden age of PL research.
• 2022‑12‑08: Goodbye to the C++ implementation of Zig.
• 2022‑12‑06: Is Moore’s Law really dead?
• 2022‑12‑04: Building a virtual machine inside ChatGPT.
• 2022‑11‑30: Counting unique web site visitors without using cookies, UIDs, or fingerprinting.
• 2022‑11‑30: Any Game of Life pattern can be constructed from just 15 gliders.
• 2022‑11‑30: The huge Game of Life caterpillar spaceship.
• 2022‑11‑26: The EU eIDAS regulation and QWAC x.509 certificates.
• 2022‑11‑23: Takahē: An efficient multi-domain ActivityPub server.
• 2022‑11‑23: Takahē: An efficient multi-domain ActivityPub server.
• 2022‑11‑23: microblog.pub: A self-hosted, single-user, ActivityPub powered microblog.
• 2022‑11‑23: If multicast is the answer, what was the question?
• 2022‑11‑23: Building the fastest Lua interpreter.. automatically!
• 2022‑11‑22: A jq255 elliptic curve specification, and a retrospective.
• 2022‑11‑21: Why the OpenSSL punycode vulnerability was not detected by fuzz testing.
• 2022‑11‑21: Is wine fake?
• 2022‑11‑20: From culinary dud to stud: how Dutch plant breeders built a brussels sprouts boom.
• 2022‑11‑20: Literature Clock
• 2022‑11‑19: GitOpper: GitOps without Kubernetes.
• 2022‑11‑19: C23 implications for C libraries.
• 2022‑11‑19: The truffle industry is a big scam. Not just truffle oil, everything.
• 2022‑11‑18: Will we have a negative leap second?
• 2022‑11‑17: A guide to error handling in Rust.
• 2022‑11‑17: Who controls the Internet? A survey of authoritative DNS server diversity.
• 2022‑11‑16: Who first thought of the notion of polynomial time? (featuring the Columbus principle)
• 2022‑11‑16: git-absorb: git commit --fixup, but automatic.
• 2022‑11‑16: Absorbing commit changes in Mercurial 4.8.
• 2022‑11‑14: psyche-c: automatic compilation of partially-available sources.
• 2022‑11‑14: Rust and C++ interoperability.
• 2022‑11‑14: Canary in the kernel mine: exploiting and defending against same-type object reuse.
• 2022‑11‑11: Seeing through hardware counters: a journey to threefold performance increase.
• 2022‑11‑10: BRAVO: biased locking for reader-writer locks.
• 2022‑11‑10: Scalable reader-writer locks.
• 2022‑11‑10: Cloning the Linux kernel in under a minute with gitoxide.
• 2022‑11‑10: Why is Apple Rosetta 2 fast?
• 2022‑11‑09: What is PostgreSQL commitfest?
• 2022‑11‑08: C isn't a programming language anymore.
• 2022‑11‑06: The SAFe delusion.
• 2022‑11‑05: The longest periods of British Summer Time.
• 2022‑11‑03: Comparing TCP and QUIC.
• 2022‑11‑03: Sugar substitutes surprise.
• 2022‑10‑27: Contention on multi-threaded regex matching in Rust.
• 2022‑10‑26: Where else in London are there pylons?
• 2022‑10‑26: Time is an illusion, Unix time doubly so...
• 2022‑10‑24: Buffers on the edge: Python and Rust.
• 2022‑10‑18: Maidenhead locator system map (with small squares).
• 2022‑10‑15: Announcing Algol 68 Genie 3.0
• 2022‑10‑14: Make your QEMU 9p server 10 times faster with this one weird trick.
• 2022‑10‑14: Modes considered harmful.
• 2022‑10‑10: The Google plasma globe USB keystroke injection attack.
• 2022‑10‑08: Slides from a lecture series on algebraic geometry for computer graphics.
• 2022‑10‑07: Hard mode Rust.
• 2022‑10‑07: On the DeepMind AlphaTensor new matrix multiplication algorithms.
• 2022‑10‑06: In-place construction for Rust.
• 2022‑10‑04: C++ chrono-compatible low-level date algorithms.
• 2022‑10‑04: Illuminating synchronization edges for ThreadSanitizer.
• 2022‑10‑02: The first RISC: John Cocke and the IBM 801.
• 2022‑10‑01: Adversarial collaboration.
• 2022‑10‑01: 9 puzzles to convince you you don't understand dependence.
• 2022‑09‑30: Querying PostgreSQL tables from DuckDB.
• 2022‑09‑30: The thorny problem of keeping the Internet’s time.
• 2022‑09‑29: How to build a personal webpage from scratch.
• 2022‑09‑28: Linux kernel __is_constexpr macro.
• 2022‑09‑28: What is PL research and how is it useful?
• 2022‑09‑27: The web site performance golden rule.
• 2022‑09‑26: Zen4's AVX512 teardown.
• 2022‑09‑26: The curious design of skateboard trucks.
• 2022‑09‑18: GCC's new fortification level: The gains and costs.
• 2022‑09‑18: Finding a second bug in glibc’s condition variable with TLA+.
• 2022‑09‑18: Geometric algebra: what is the inverse of a vector?
• 2022‑09‑17: Qiwi: A quick, emulation-focused launcher for QEMU.
• 2022‑09‑12: Ladybird: A new cross-platform browser from the SerenityOS project.
• 2022‑09‑09: Parallel curves of cubic Béziers.
• 2022‑09‑08: bstr: A byte string library for Rust.
• 2022‑09‑07: Programming with union, intersection, and negation types.
• 2022‑09‑06: Someone’s been messing with Python’s floating point subnormals!
• 2022‑09‑06: What’s the smallest variety of CHERI? A 32 bit RISC-V CHERI.
• 2022‑09‑04: The as-if infinitely ranged (AIR) integer model.
• 2022‑09‑04: Reviving the coolest film scanner you've never heard of.
• 2022‑09‑04: I ran the worlds largest DDoS-for-Hire empire and CloudFlare helped.
• 2022‑08‑31: Commodore 64 Theremin.
• 2022‑08‑30: Packed structs in Zig make bit/flag sets trivial.
• 2022‑08‑29: CSS classes considered harmful.
• 2022‑08‑28: Weird monitor bugs people sent me in the last 5 years.
• 2022‑08‑26: The Jupyter+git problem is now solved.
• 2022‑08‑23: VS Code: What's the deal with the telemetry?
• 2022‑08‑20: Faster zlib/DEFLATE decompression on arm64 and x86.
• 2022‑08‑15: Retrofitted parallelism considered grossly sub-optimal.
• 2022‑08‑14: Getting the world record in HATETRIS.
• 2022‑08‑11: Brimar thermionic products great British valve project.
• 2022‑08‑07: Computing Adler32 checksums at 41 GB/s.
• 2022‑08‑04: The original social network: other people’s websites.
• 2022‑08‑04: C99 doesn't need function bodies: VLAs are Turing complete.
• 2022‑08‑03: How I do (and don’t) prepare a talk for a tech conference.
• 2022‑08‑02: A new `impl Trait` for Rust.
• 2022‑07‑31: Linux kernel lock engineering principles.
• 2022‑07‑29: A simplified implementation of TypeScript's type system written in TypeScript's type system.
• 2022‑07‑29: Actually Portable Executables with Rust and Cosmopolitan libc.
• 2022‑07‑29: Stop aggregating away the signal in your data.
• 2022‑07‑28: execline: a small scripting language.
• 2022‑07‑27: Twenty years of Valgrind.
• 2022‑07‑22: Why the NRO is defending AFRINIC.
• 2022‑07‑22: Formal CHERI: rigorous engineering and design-time proof of full-scale architecture security properties.
• 2022‑07‑21: The origin of “Cry uncle!”
• 2022‑07‑19: Gaussian blue noise.
• 2022‑07‑19: CORE-MATH: open source mathematical functions with correct rounding.
• 2022‑07‑13: Intel floating point reference sheet.
• 2022‑07‑07: UDDSketch: a C implementation of DDSketch with a better uniform collapsing strategy.
• 2022‑06‑20: A closer look at CVSS scores.
• 2022‑06‑19: Advancing the state of the art for C++ std::unordered_map implementations.
• 2022‑06‑14: STxP70 / STHORM / P2012: ST's secret microcontroller.
• 2022‑06‑04: Remembering Ned Freed (1959-2022).
• 2022‑05‑30: How read-intensive is Linux's use of RCU? (And what is its latency?)
• 2022‑05‑29: Thoughts on FORTH programming.
• 2022‑05‑29: RFC 3339 vs ISO 8601
• 2022‑05‑27: Searching 32 million academic papers for obscene acronyms hidden in the titles.
• 2022‑05‑25: You CAN average percentiles (if you know what you are doing).
• 2022‑05‑25: Modern programming languages require generics.
• 2022‑05‑22: Happy 10th birthday to Godbolt’s Compiler Explorer!
• 2022‑05‑20: Logging C function calls with cosmopolitan libc.
• 2022‑05‑17: DevOps inspiration from Toyota Production System and Lean considered harmful.
• 2022‑05‑12: Fuzzing an eBPF implementation in Rust.
• 2022‑05‑10: Hardening snmalloc.
• 2022‑05‑09: Agile and the long crisis of software.
• 2022‑05‑07: Xilem: an architecture for UI in Rust.
• 2022‑05‑07: Identity crisis: sequence vs UUID as primary key.
• 2022‑05‑07: Shaving is too expensive.
• 2022‑05‑06: A mystery of unnecessary Rust crate recompilation.
• 2022‑04‑30: Implementing a safe garbage collector in Rust.
• 2022‑04‑29: Pražský Orloj: Prague astronomical clock simulator.
• 2022‑04‑27: SELinux is unmanageable; just turn it off if it gets in your way.
• 2022‑04‑26: The problem with mechanical keyboard switch reviews.
• 2022‑04‑25: Why LSP? On two-sided markets and N*M.
• 2022‑04‑25: Low-latency high-throughput garbage collection.
• 2022‑04‑21: Coherence and crate-level where-clauses in Rust.
• 2022‑04‑20: Changing llvm libc++ std::sort() at Google and beyond.
• 2022‑04‑18: Locales, encodings, Unicode, and C++.
• 2022‑04‑18: It's always DNS . . . except when it's not: A deep dive through gRPC, Kubernetes, and AWS networking.
• 2022‑04‑18: Exponentially better rotations.
• 2022‑04‑16: Why I avoid async/await in JavaScript.
• 2022‑04‑11: Pointers Are Complicated III: pointer-integer casts exposed. (strict provenance in Rust)
• 2022‑04‑10: Rust's unsafe pointer types need an overhaul.
• 2022‑04‑10: The struggle of using native emoji on the web.
• 2022‑04‑10: Abstraction: not what you think it is.
• 2022‑04‑10: The design of the RELAX NG XML schema language.
• 2022‑04‑10: Beyond bufferbloat: End-to-end congestion control cannot avoid latency spikes.
• 2022‑04‑10: So you want to study mathematics…
• 2022‑04‑10: Authenticated bootstrapping of DNSSEC delegations.
• 2022‑04‑04: Horrible edge cases to consider when cataloguing music.
• 2022‑04‑01: Laura Kuenssberg’s time as BBC Political Editor has been a catastrophic, systemic failure.
• 2022‑04‑01: DDC OLED: how to drive a tiny display from an HDMI port.
• 2022‑04‑01: Three big myths about Covid Omicron.
• 2022‑03‑31: Moderating content supports the principles of free speech.
• 2022‑03‑30: The British Empire was much worse than you realize.
• 2022‑03‑30: GPT-3 can run code (ish).
• 2022‑03‑28: 3D printed Portal turret build guide.
• 2022‑03‑28: “You build it, you run it” playbook.
• 2022‑03‑24: DNSSEC algorithms for TLDs (and everyone else).
• 2022‑03‑21: Lanai (the Myrinet CPU architecture) in LLVM.
• 2022‑03‑19: BOOTP and ARP history.
• 2022‑03‑18: Random number generator enhancements for Linux 5.17 and 5.18..
• 2022‑03‑17: C isn't a programming language anymore.
• 2022‑03‑16: Daylight saving time gripe assistant tool.
• 2022‑03‑14: RP2040 Doom.
• 2022‑03‑12: Marginalia web search engine.
• 2022‑03‑12: The life of an optimization barrier in Rust and Wasm.
• 2022‑03‑11: Implementing network time security (NTP NTS) at the hardware level.
• 2022‑03‑10: A Redis Lua sandbox escape on Debian and its derivatives.
• 2022‑03‑04: Dennis Meadows on the 50th anniversary of the publication of The Limits to Growth.
• 2022‑03‑02: Using DNAME for reverse DNS of inter-RIR transferred IP address ranges.
• 2022‑02‑26: Curious lack of sprintf scaling.
• 2022‑02‑23: A cursed RDMA bug.
• 2022‑02‑22: A collection of GPS disciplined oscillator designs.
• 2022‑02‑19: Jujutsu: A Git-compatible DVCS that is both simple and powerful.
• 2022‑02‑19: Destroy all values: designing deinitialization in programming languages.
• 2022‑02‑19: Mergers ruin everything.
• 2022‑02‑19: Building an intelligent Emacs.
• 2022‑02‑19: How a Saudi woman's iPhone revealed NSO Group’s hacking.
• 2022‑02‑17: PX-1000Cr: Deliberate weakening of a cryptographic algorithm by the NSA.
• 2022‑02‑15: Upgrading an iPod in 2022.
• 2022‑02‑15: A decade of major cache incidents at Twitter.
• 2022‑02‑15: Journeying into XDP: Fully-fledged DNS service augmentation.
• 2022‑02‑06: lon lat or lat lon?
• 2022‑02‑03: Yes, I can query a SQLite database in CSS.
• 2022‑02‑03: Optimizing GoAWK with a bytecode compiler and virtual machine.
• 2022‑02‑01: Async embedded Rust vs FreeRTOS + C showdown!
• 2022‑01‑30: Uninitialized memory: unsafe Rust is too hard.
• 2022‑01‑29: An update on rust/coreutils.
• 2022‑01‑28: Lights at sea: a map of lighthouses.
• 2022‑01‑28: Summary of the USA federal government’s zero-trust memo.
• 2022‑01‑27: Magic-trace: Diagnosing tricky performance issues easily with Intel Processor Trace.
• 2022‑01‑27: Non-lazy futures considered harmful in Rust.
• 2022‑01‑27: Stop brainstorming.
• 2022‑01‑26: Machine readable specifications at scale.
• 2022‑01‑25: World of constellations: a multicultural star map.
• 2022‑01‑25: The truth about inflation.
• 2022‑01‑18: Dun, Dun Duuun! Where did pop culture’s most dramatic sound come from?
• 2022‑01‑18: GPS.
• 2022‑01‑18: arXiv.org reaches a milestone and a reckoning.
• 2022‑01‑17: Why Macron’s use of the French swear word ‘emmerder’ is so hard to translate.
• 2022‑01‑16: Covid-19 will never become endemic.
• 2022‑01‑14: Are you sure you want to use mmap() in your database management system?
• 2022‑01‑14: Nominative determinism in hospital medicine.
• 2022‑01‑13: Hate leap seconds? Imagine a negative one!
• 2022‑01‑13: Ghost in the ethernet optic.
• 2022‑01‑13: PCIe 6 overview.
• 2022‑01‑13: Async Rust in ScyllaDB: performance, pitfalls, profiling.
• 2022‑01‑09: Matthew Somerville’s Inky dashboard.
• 2022‑01‑09: Will Britain survive?
• 2022‑01‑09: How to check you're in the initial pid namespace?
• 2022‑01‑03: Hacking a VW Golf power steering ECU.
• 2022‑01‑03: On recurrences converging to the wrong limit in finite precision, and some new examples.
• 2022‑01‑01: A brief history of Dell Unix.
• 2022‑01‑01: Susie Dent's guide to swearing.
• 2021‑12‑31: Some sanity for C and C++ development on Windows.
• 2021‑12‑28: Why Pascal is Not My Favorite Programming Language. (troff source)
• 2021‑12‑28: Software Tools in C++.
• 2021‑12‑27: What if the Flu isn’t “just the Flu?”
• 2021‑12‑26: State of Valhalla, part 1: value types for the JVM.
• 2021‑12‑23: fq: jq for binary formats.
• 2021‑12‑23: Spotting fake face masks. (FFP2/N95/KN95)
• 2021‑12‑18: age-plugin-yubikey: YubiKey plugin for age encryption.
• 2021‑12‑18: untwister: a PRNG seed recovery tool.
• 2021‑12‑18: PostgreSQL is a great pub/sub and job server.
• 2021‑12‑17: A brutally effective hash function in Rust.
• 2021‑12‑16: gRPC best practices.
• 2021‑12‑16: Cranelift progress report: a look back at 2021.
• 2021‑12‑15: The Muppet Christmas Carol is the best adaptation of A Christmas Carol.
• 2021‑12‑15: IPv4 address markets.
• 2021‑12‑05: Tips on adding JSON output to your command line utility.
• 2021‑12‑05: Async cancellation in Rust.
• 2021‑12‑05: Securing updates for GNU Guix.
• 2021‑12‑05: Rclone syncs your files to cloud storage.
• 2021‑12‑05: restic: backups done right!
• 2021‑12‑03: Don't make my mistakes: common infrastructure errors i've made.
• 2021‑12‑02: Why movie dialogue has become more difficult to understand.
• 2021‑12‑02: Ideal monitor rotation for programmers .
• 2021‑12‑02: Tvix: we are rewriting Nix.
• 2021‑12‑01: libtree: ldd as a tree saying why a library is found or not.
• 2021‑12‑01: This shouldn't have happened: A vulnerability postmortem.
• 2021‑12‑01: An illustrated guide to elliptic curve cryptography validation.
• 2021‑11‑29: Improving over-constrained Rust APIs.
• 2021‑11‑29: Stack safety for free?
• 2021‑11‑28: Amethyst: an automatic tiling window manager for macOS.
• 2021‑11‑28: kmonad: an advanced keyboard manager.
• 2021‑11‑26: The return of JavaScript for Mac OS automation, instead of AppleScript.
• 2021‑11‑24: IDEs and macros and Rust.
• 2021‑11‑21: DwarFS: A fast high compression read-only file system.
• 2021‑11‑21: elfshaker stores binary objects efficiently; designed for manyclangs.
• 2021‑11‑21: Dell XPS13 RAM upgrade.
• 2021‑11‑18: Support for IPv6 link local addresses in browsers.
• 2021‑11‑18: Getting started with Rust on a Raspberry Pi Pico.
• 2021‑11‑18: Understanding HKDF.
• 2021‑11‑18: Vulnerabilities show why STARTTLS should be avoided if possible.
• 2021‑11‑18: Mononym: type-level named values in Rust.
• 2021‑11‑14: Tests aren’t enough: adding type hints to Python urllib3.
• 2021‑11‑13: The weirdest QNX bug I've ever encountered.
• 2021‑11‑13: It's now possible to sign arbitrary data with your SSH keys.
• 2021‑11‑12: Overview of the Rust compiler.
• 2021‑11‑11: Speed of Rust vs C.
• 2021‑11‑04: An oral history of Bank Python.
• 2021‑11‑01: C++ coroutines do not spark joy.
• 2021‑10‑26: Comparing open source BGP stacks.
• 2021‑10‑26: austral: a systems language with linear types.
• 2021‑10‑26: bitbottle: an archive file format (in Rust).
• 2021‑10‑25: blamer.el: A git blame plugin for emacs inspired by VS Code's GitLens plugin.
• 2021‑10‑24: Measuring C++ std::unordered_map badness.
• 2021‑10‑23: Raspberry Pi 3 fastboot in less than 2 seconds.
• 2021‑10‑23: Can we trust Microsoft with Open Source?
• 2021‑10‑23: A cool Rust optimization story.
• 2021‑10‑23: Coding for non-programmers: we need better web GUI automation tools.
• 2021‑10‑21: Stupid tricks with io_uring: a server that does zero syscalls per request.
• 2021‑10‑21: Context-preserving error handling in Rust.
• 2021‑10‑21: Function pipelines: Building functional programming into PostgreSQL using custom operators.
• 2021‑10‑21: Did the Big Bang begin from a singularity? Not anymore.
• 2021‑10‑21: Making slow Rust code fast.
• 2021‑10‑21: Social media doesn't turn people into assholes, and everyone's wrong about echo chambers.
• 2021‑10‑20: I couldn’t debug the code because of my name: unicode pathname bugs in JetBrains IDEs.
• 2021‑10‑18: Serialization-based undo with zstd compression.
• 2021‑10‑18: What every software engineer should know about search.
• 2021‑10‑18: The undocumented Microsoft "Rich" PECOFF header.
• 2021‑10‑13: Kathleen Stock, TERF.
• 2021‑10‑13: A plug-compatible 100 MHz FPGA 6502.
• 2021‑10‑13: The problem with function namespaces and Lisp macros.
• 2021‑10‑11: MMP at 25: how proportional representation changed New Zealand forever.
• 2021‑10‑11: Better operator precedence.
• 2021‑10‑11: Benchmarking oksh (OpenBSD Korn shell) with lots of C compilers.
• 2021‑10‑06: How ISO C became unusable for operating system development.
• 2021‑10‑04: CBMC: C bounded model checker.
• 2021‑10‑03: OpenHaystack: tracking your Bluetooth devices with Apple's "Find My" network
• 2021‑10‑03: R, OpenMP, MKL, disaster.
• 2021‑10‑02: Clarifying the structure and nature of left-wing authoritarianism.
• 2021‑09‑30: squawk: a linter for PostgreSQL, focused on migrations.
• 2021‑09‑30: JSON in PostgreSQL: how to use it right.
• 2021‑09‑30: Second software release for CHERI-RISC-V and Arm Morello capability architectures.
• 2021‑09‑30: Rust for the polyglot programmer.
• 2021‑09‑30: The Biggest Churches in the World: Anglo-Norman eleventh-century cathedrals.
• 2021‑09‑27: Dealing with the Roman Calendar.
• 2021‑09‑26: A history of library hand.
• 2021‑09‑21: HIBA: Host Identity Based Authorization for SSH.
• 2021‑09‑21: Index, a history of the.
• 2021‑09‑21: Google Docs in a clean-room browser.
• 2021‑09‑21: There was no formal methods winter.
• 2021‑09‑21: A giant space rock demolished an ancient Middle Eastern city and everyone in it, possibly inspiring the Biblical story of Sodom.
• 2021‑09‑19: How does Ouroboros relate to RINA, the Recursive InterNetwork Architecture?
• 2021‑09‑19: Can you see the Republic of Ireland from England?
• 2021‑09‑18: The Negro Subversive on Critical Race Theory.
• 2021‑09‑17: Hacking CloudKit: How I accidentally deleted your Apple Shortcuts.
• 2021‑09‑17: TRIPOS historical sources.
• 2021‑09‑16: Exploring 120 years of timezones.
• 2021‑09‑16: Go to sleep little iPhone: lost broadcasts on WiFi.
• 2021‑09‑15: DART: the Disability Attitude Re-adjustment Tool.
• 2021‑09‑15: Freedom of Information as a tool for making cycle routes more accessible.
• 2021‑09‑15: Taking legal action on inaccessible cycleway barriers.
• 2021‑09‑15: Single-pass online statistics algorithms.
• 2021‑09‑14: An existential crisis resolved: type inference for first-class existential types.
• 2021‑09‑14: logos: create ridiculously fast lexers in Rust.
• 2021‑09‑14: HTTP Cache-Control recommendations.
• 2021‑09‑14: Type-checked keypaths in Rust.
• 2021‑09‑14: A tale of making a company-wide psqlrc to use with pgbouncer.
• 2021‑09‑14: OLAP != OLAP Cube.
• 2021‑09‑14: Ora2PG now supports oracle_fdw to increase data migration speed.
• 2021‑09‑14: Emulating AMD approximate arithmetic instructions on Intel.
• 2021‑09‑12: Okhsv and Okhsl: two new color spaces for color picking.
• 2021‑09‑09: Server traffic shaping on Linux with CAKE.
• 2021‑09‑09: Kill It With Fire: dealing with legacy systems. (book review)
• 2021‑09‑06: Computational hierarchy of elementary cellular automata.
• 2021‑09‑05: Why are a billion years of rock missing from the geological record?
• 2021‑09‑05: Notes from a 1984 trip to Xerox PARC.
• 2021‑09‑04: Linux tmpfs inode corruption: introducing inode64.
• 2021‑09‑04: A nasty bit of implicit timezone behavior in Golang.
• 2021‑09‑03: The scandalous history of the last rotor cipher machine.
• 2021‑09‑02: Netflix audio description style guide.
• 2021‑09‑01: Moiré no more: using FFT to remove halftone patterns.
• 2021‑09‑01: Moiré no more: using FFT to remove halftone patterns.
• 2021‑09‑01: In defense of blub studies.
• 2021‑08‑31: APOLLO 68080: high performance 68k processor on FPGA.
• 2021‑08‑31: The demise of the once mighty Cambridge and District Co-operative Society.
• 2021‑08‑30: Most information about disinformation is misinformation.
• 2021‑08‑29: Why is the S combinator an S?
• 2021‑08‑29: Four months with Ada.
• 2021‑08‑28: jsc: JavaScript on the macOS command line.
• 2021‑08‑26: Inko: Friendship ended with the garbage collector.
• 2021‑08‑26: Flexible microprocessor could enable an 'internet of everything'.
• 2021‑08‑26: PragmatIC Semiconductor made a flexible 6502 in two weeks.
• 2021‑08‑25: Hiding images in plain sight: an acrylic magic window that can project a picture.
• 2021‑08‑24: Life before Unicode in Russia.
• 2021‑08‑23: One does not simply calculate the absolute value.
• 2021‑08‑21: Index 1,600,000,000 keys with finite state automata and Rust.
• 2021‑08‑21: Tesla Dojo: a custom chip for very high capacity AI training.
• 2021‑08‑20: Encoding of immediate values on AArch64.
• 2021‑08‑20: Monks Wood Wilderness: 60 years ago, scientists let a farm field rewild; here's what happened.
• 2021‑08‑20: Mutable statics in Rust have scary superpowers! Do not use them!
• 2021‑08‑20: Patterns in confusing explanations.
• 2021‑08‑19: The quest to recreate a lost and ‘terrifying’ medieval mead.
• 2021‑08‑18: Exploring Clang/LLVM optimization on a programming horror.
• 2021‑08‑17: The Wendelstein 7-X fusion stellarator proves its efficiency.
• 2021‑08‑17: Behind the scenes at South Kensington tube station’s escalator replacement project.
• 2021‑08‑17: Speeding up `atan2f` by 50x.
• 2021‑08‑16: Namespaced De Bruijn indices.
• 2021‑08‑15: Classical data structures that can outperform learned indexes.
• 2021‑08‑14: Emacs development charts, 10×10%.
• 2021‑08‑14: Preprint déjà vu: a FAQ about the arXiv.
• 2021‑08‑14: A probabilistic solution to the three-body problem.
• 2021‑08‑11: Why is tech illustration stuck on repeat?
• 2021‑08‑11: A little bit about PRNG stuff in Rust.
• 2021‑08‑09: How BCPL evolved from CPL.
• 2021‑08‑09: The rise of Meson.
• 2021‑08‑08: Edward Luper’s 36 Views of the BT Tower.
• 2021‑08‑07: A USB adapter for a Depraz mouse.
• 2021‑08‑07: The tao of Unicode sparklines.
• 2021‑08‑06: HTTP/2 desync attacks.
• 2021‑08‑03: Unix for TOPS-20 users. (1987)
• 2021‑08‑03: Choosing properties for property-based testing.
• 2021‑08‑03: Making reasonable use of computer resources.
• 2021‑07‑31: strcpy: a niche function you don't need.
• 2021‑07‑30: B-tree path hints.
• 2021‑07‑30: One tenth of a second.
• 2021‑07‑29: One lost methyl group = huge amounts of food production.
• 2021‑07‑28: Cryptanalysis of Meow Hash.
• 2021‑07‑28: The fall of the SKI civilization.
• 2021‑07‑27: Why neoliberalism needs neofascists.
• 2021‑07‑21: Keyboard rollover and lockout.
• 2021‑07‑18: Inserting one billion rows into SQLite in under a minute.
• 2021‑07‑16: The development of Chez Scheme.
• 2021‑07‑13: CMake: the dark arts.
• 2021‑07‑13: Updating the Golang memory model.
• 2021‑07‑11: Ribbon filter: Practically smaller than Bloom and Xor.
• 2021‑07‑11: It’s not always iCache.
• 2021‑07‑11: Inline in Rust.
• 2021‑07‑10: Against SQL.
• 2021‑07‑09: How Intel financialized and lost leadership in semiconductor fabrication.
• 2021‑07‑09: A survey of approaches to securing BGP and inter-domain routing.
• 2021‑07‑09: mull: Practical mutation testing for C and C++.
• 2021‑07‑08: Compiling Rust is NP-hard: the pattern match exhaustiveness checker as a SAT solver.
• 2021‑07‑08: Dumping and extracting the SpaceX Starlink user terminal firmware.
• 2021‑07‑07: Programming language memory models.
• 2021‑07‑07: Extensions are moving away from the macOS kernel.
• 2021‑07‑07: Hacker News folk wisdom on visual programming.
• 2021‑07‑07: rustviz: interactive visualization of ownership and borrowing.
• 2021‑07‑06: How Black handles comments when Python's grammar ignores them.
• 2021‑07‑05: GitHub Copilot is not infringing your copyright.
• 2021‑07‑05: TCP Fast Open? Not so fast!
• 2021‑07‑04: Electron tube new automatic computer: a homemade valve computer.
• 2021‑07‑04: The dawn of formalized mathematics.
• 2021‑07‑04: Ode to a world-saving idea: attribution error and cognitive empathy.
• 2021‑07‑03: wasm2ps: compile a small subset of WebAssembly to PostScript. (using wasm2wat)
• 2021‑07‑03: Phase-in codes.
• 2021‑07‑01: Hardware memory models.
• 2021‑06‑30: Where there’s a grille: the hidden portals to London’s underworld.
• 2021‑06‑29: British flag protocol: flying the union jack.
• 2021‑06‑29: Reinventing the automobile: the first skateboard platform for electric vehicles.
• 2021‑06‑29: Temporal: getting started with JavaScript’s new date time API.
• 2021‑06‑28: How to evaluate Emacs Lisp in regex search and replace.
• 2021‑06‑27: systemd, 10 years later: a historical and technical retrospective.
• 2021‑06‑27: Why did we ever think the first programming language didn't matter?
• 2021‑06‑26: pydantic: data validation and settings management using Python type annotations.
• 2021‑06‑22: Async Rust: futures, tasks, wakers; oh my!
• 2021‑06‑22: What is CapTP, and what does it enable?
• 2021‑06‑21: Expanding TeX's \newif.
• 2021‑06‑20: What do you call a Rust pointer we stole the high bits off? An ointer.
• 2021‑06‑18: Eliminating data races in Firefox with Thread Sanitizer.
• 2021‑06‑16: Introducing cap-std, a capability-based version of the Rust standard library.
• 2021‑06‑15: Celebrating 30 years of Europe’s first root name server.
• 2021‑06‑14: Let’s port Doom to an IKEA TRÅDFRI lamp!
• 2021‑06‑13: A few thoughts on Fuchsia security.
• 2021‑06‑13: How to handle secrets on the command line.
• 2021‑06‑12: Do you really need Redis? PostgreSQL does queuing, locking, and pub/sub.
• 2021‑06‑11: Can memcpy be implemented in LLVM IR?
• 2021‑06‑11: cap: an allocator that can track and limit memory usage in Rust.
• 2021‑06‑11: schemars: generate JSON schema from Rust code.
• 2021‑06‑11: Time and date syntax used by systemd.
• 2021‑06‑11: Don’t feed the thought leaders.
• 2021‑06‑11: Behavior inheritance in Rust.
• 2021‑06‑08: Kerckhoffs’s law for security engineers.
• 2021‑06‑07: Using a SmartCard HSM for DNSSEC with BIND, Knot DNS, and LDNS/NSD.
• 2021‑06‑06: Ordnance Survey height benchmark locations.
• 2021‑06‑05: From Julia to Rust.
• 2021‑06‑05: Integer log10: make your lookup table do more.
• 2021‑06‑04: Anatomy of a Linux DNS lookup.
• 2021‑06‑04: Firefox Proton UI userChrome.css fixes.
• 2021‑06‑04: Firefox 89 tab appearance fixes with userchrome.css.
• 2021‑06‑04: Handling global associative arrays in PostgreSQL.
• 2021‑06‑03: A new Protocol Buffers generator for Golang.
• 2021‑06‑03: Design issues in LLVM IR.
• 2021‑06‑03: How malloc broke Serenity's JPGLoader, or: how to win the lottery.
• 2021‑06‑02: Practical Reed-Solomon for programmers.
• 2021‑06‑01: How to test your code.
• 2021‑05‑31: PostGIS at 20: the beginning.
• 2021‑05‑29: Joseph Weizenbaum's original ELIZA.
• 2021‑05‑28: A year in the Nakagin tower’s metabolist future of 1972.
• 2021‑05‑27: An introduction to Jorvik, Ada’s new tasking profile.
• 2021‑05‑27: Of donkeys, mules, and horses: data structures for network prefixes in Rust.
• 2021‑05‑27: Reciprocals in Rust: baseline implementations should be predictable.
• 2021‑05‑25: RefinedC: automating the foundational verification of C code with refined ownership types.
• 2021‑05‑24: Counterexamples in type systems.
• 2021‑05‑23: rustc_codegen_gcc can now run libcore’s tests and pass most of them!
• 2021‑05‑23: GhostCell: separating permissions from data in Rust.
• 2021‑05‑20: Language compilation speed comparison.
• 2021‑05‑14: Benchmarking division and libdivide on Apple M1 and Intel AVX512.
• 2021‑05‑12: Getting random rows very much faster with tablesample in PostgreSQL.
• 2021‑05‑10: Better performance for dynamic linking with -fno-semantic-interposition.
• 2021‑05‑08: The byte order fiasco.
• 2021‑05‑06: EverParse: Hardening critical attack surfaces with formally proven message parsers.
• 2021‑05‑05: Linear Clock: Solar.
• 2021‑05‑04: Fully automated bootstrapping from source.
• 2021‑05‑03: Dissecting the Apple M1 GPU, part IV.
• 2021‑05‑02: Hosting SQLite databases on Github Pages (or any static file hoster).
• 2021‑05‑02: The honest troubleshooting code of conduct.
• 2021‑05‑02: Handling time when programming.
• 2021‑05‑02: Query engines: push vs. pull.
• 2021‑04‑29: An interview with Linus Torvalds on Linux and Git.
• 2021‑04‑28: Internal consistency in streaming systems.
• 2021‑04‑26: Plan 9 history in git, from 1992-09-21 to 2015-01-10.
• 2021‑04‑26: Let’s build a new service manager for Alpine Linux!
• 2021‑04‑25: Parsing protobuf at 2+GB/s: how I learned to love tail calls in C.
• 2021‑04‑24: The mystery of AS8003 and legacy US DoD IPv4 address space.
• 2021‑04‑22: Earth Restored: newly retouched photographs from the Apollo lunar missions.
• 2021‑04‑21: Exploiting vulnerabilities in Cellebrite UFED and Physical Analyzer from Signal's perspective.
• 2021‑04‑19: Dissecting the Apple M1 GPU, part III.
• 2021‑04‑17: Lars Wirzenius would like to review your README.
• 2021‑04‑16: Actually, you are rolling your own crypto.
• 2021‑04‑15: Rust shenanigans: return type polymorphism.
• 2021‑04‑15: The design of tokio-uring: Linux io_uring support for Rust.
• 2021‑04‑14: fuzzcheck-rs: Structure-aware, in-process, coverage-guided fuzzing engine for Rust.
• 2021‑04‑12: What exactly was the point of [ “x$var” = “xval” ]?
• 2021‑04‑11: Using PyTorch and NumPy? You're making a mistake.
• 2021‑04‑09: Asahi Linux for Apple M1: progress report, January / February 2021.
• 2021‑04‑07: Protecting PostgreSQL from FreeBSD's OOM killer.
• 2021‑04‑07: Several ways is which software can be surprisingly slow.
• 2021‑04‑07: Fast and extensible equality saturation with egg and Rust.
• 2021‑04‑06: Debugging random slow writes with GIN indexes in PostgreSQL.
• 2021‑04‑06: Foreign Data Wrappers for migrating from Oracle to PostgreSQL.
• 2021‑04‑06: Eliminating data races in Firefox with thread sanitizer: a technical report.
• 2021‑04‑06: Wuffs has the fastest, safest PNG decoder in the world.
• 2021‑04‑06: Ghosts of OSI: the spectre haunting the Internet.
• 2021‑04‑05: TextEdit TXT/HTML type sniffing vulnerability on macOS (CVE-2019-8761).
• 2021‑04‑04: paged.js: beautiful PDFs from HTML.
• 2021‑04‑04: A history of IRC (Internet Relay Chat).
• 2021‑04‑04: Why Julia is turning heads in 2021.
• 2021‑04‑04: Why daylight saving time has not stopped yet in Europe.
• 2021‑04‑03: Where is HTTP/3 right now?
• 2021‑04‑03: Ink traps and light traps in font design.
• 2021‑04‑02: Ionica: how the British weather killed a billion pound tech company.
• 2021‑04‑01: Speeding up crash recovery and VACUUM in PostgreSQL 14.
• 2021‑04‑01: Using Rust to corrode insane Python run-times.
• 2021‑04‑01: How does Golang know time.Now?
• 2021‑04‑01: avo: Generate x86 assembly with Golang.
• 2021‑03‑30: Terrible choices: MySQL.
• 2021‑03‑30: MySQL: do not pass this way again.
• 2021‑03‑30: In MySQL, never use “utf8”. Use “utf8mb4”.
• 2021‑03‑30: The sixtyforgan: a Commodore 64 with a spring reverb; chiptunes like a church organ.
• 2021‑03‑30: Hello, HPy.
• 2021‑03‑29: Flicker-free Elite on the BBC Micro (like the BBC Master).
• 2021‑03‑29: Notes on the Internet Congestion Control Research Group meeting at IETF 110.
• 2021‑03‑29: The actual OSI model.
• 2021‑03‑28: Implicit In-order Forests: Zooming a billion trace events at 60fps.
• 2021‑03‑28: Developer tools can be magic. Instead, they collect dust.
• 2021‑03‑28: Pin and suffering in async Rust.
• 2021‑03‑27: Sundial: fault-tolerant clock synchronization for datacenters.
• 2021‑03‑26: A look back at asynchronous Rust.
• 2021‑03‑26: Parallel Programming: Second Edition.
• 2021‑03‑26: Speculating the entire x86-64 instruction set in seconds with this one weird trick.
• 2021‑03‑26: Dynamic memory allocation in constexpr in C++20.
• 2021‑03‑26: JET.jl: static type checker with type inference for Julia.
• 2021‑03‑25: Julia 1.6 highlights.
• 2021‑03‑25: Counting cycles and instructions on the Apple M1 processor.
• 2021‑03‑23: Automatic video editing for presentations.
• 2021‑03‑20: Regexploit: a tool for finding DoS-able regular expressions.
• 2021‑03‑19: Fontemon: the world’s first video game in a font!
• 2021‑03‑19: Consistent overhead byte stuffing for binary logs.
• 2021‑03‑19: MOnSter 6502
• 2021‑03‑18: How GitHub found and fixed a rare race condition in session handling.
• 2021‑03‑18: Country centered map projections.
• 2021‑03‑18: Stealing arbitrary GitHub Actions secrets.
• 2021‑03‑18: Writing a PostgreSQL formatter / pretty printer in Rust.
• 2021‑03‑18: Memory saturated MySQL.
• 2021‑03‑18: Algebraic graphs with class in Haskell.
• 2021‑03‑18: 17 weird facts about the Hunspell dictionary format.
• 2021‑03‑17: frawk: an efficient awk-like programming language.
• 2021‑03‑17: Why COBOL isn't the problem.
• 2021‑03‑16: The origins and motivations of univalent foundations: computer proof verification to avoid mathematical mistakes.
• 2021‑03‑16: Improving large monorepo performance on GitHub.
• 2021‑03‑16: Correct register allocation in Cranelift by fuzzing with a symbolic checker.
• 2021‑03‑16: The prevalence, persistence, and perils of lame delegations.
• 2021‑03‑16: It’s time to stop using SMS for anything.
• 2021‑03‑15: Performance comparison: counting words in Python, Go, C++, C, AWK, Forth, and Rust.
• 2021‑03‑14: Fitting cubic Bézier curves.
• 2021‑03‑12: Measuring frecency (a combination of frequency and recency) with exponential decay.
• 2021‑03‑12: Finding Mona Lisa in the Game of Life.
• 2021‑03‑12: A brief history of network router architecture.
• 2021‑03‑12: Faster inverse BWT.
• 2021‑03‑11: Generalizing over generics aka higher kinded types in Rust.
• 2021‑03‑11: Estimating connection pool size with PostgreSQL 14 statistics.
• 2021‑03‑11: Notes from the DNS privacy workshop at NDSS 2021.
• 2021‑03‑11: Safe flexible aliasing with deferred borrows in Rust.
• 2021‑03‑11: String matching based on compile time perfect hashing in Zig.
• 2021‑03‑11: A history of CLU.
• 2021‑03‑11: inet.af/netaddr.IP: a new IP address type for Golang.
• 2021‑03‑10: HTML5 genetic algorithm 2D car thingy.
• 2021‑03‑09: Debian running on Rust coreutils.
• 2021‑03‑08: yacv (Yet Another Compiler Visualizer): LL and LR parser animations.
• 2021‑03‑07: Fast file copy with io_uring.
• 2021‑03‑07: Memory-mapped IO registers in Zig.
• 2021‑03‑07: Don’t use 7-segment displays.
• 2021‑03‑07: Why I rewrote my Rust keyboard firmware in Zig: consistency, mastery, and fun.
• 2021‑03‑06: Cleaning up your PostgreSQL database.
• 2021‑03‑06: No one is prepared for hagfish slime.
• 2021‑03‑06: Generating ePub from LaTeX.
• 2021‑03‑06: Modern text features in R.
• 2021‑03‑06: Web browser architecture and the history of window systems.
• 2021‑03‑05: Clojure from a Schemer's perspective.
• 2021‑03‑05: Waiting for PostgreSQL 14: SEARCH and CYCLE clauses.
• 2021‑03‑05: New Ansible data validation module(s).
• 2021‑03‑05: Project Champollion: reverse-engineering Rosetta 2.
• 2021‑03‑04: Solving the structured control flow problem when compiling to WebAssembly.