Russ Cox writes deep, authoritative essays on Go, compilers, floating-point algorithms, and software correctness. His work explores performance, debugging techniques, supply chain security, and the mathematical foundations behind reliable systems.
24 articles from this blog
A technical proof and algorithm for fast unrounded scaling in floating-point formatting, part of a series on floating-point printing and parsing.
A technical deep dive into simple, fast algorithms for converting floating-point numbers to and from decimal text, with a Go implementation.
A detailed analysis and new proof for Donald Knuth's fixed-point to decimal conversion program, exploring program correctness and algorithm design.
A series of technical posts exploring the challenges and solutions for formatting and printing floating-point numbers accurately and efficiently.
A debugging technique using differential code coverage to isolate code unique to a failing test, demonstrated with a Go example.
Explains hash-based bisect debugging, a technique using binary search to pinpoint bugs in compilers and runtimes, making complex debugging feel like magic.
Analysis of the malicious shell script component in the xz backdoor attack, detailing its injection and execution mechanisms.
A detailed timeline of the multi-year social engineering attack that led to a backdoor in the xz compression library, a major open source supply chain incident.
Russ Cox discusses how Go evolves, the role of data in decisions, and the introduction of opt-in telemetry in the Go toolchain.
Russ Cox shares 20 practical tips for effective Go testing, based on his GopherCon Australia talk, covering test design, coverage, and automation.
Running Ken Thompson's backdoored compiler from his classic 1983 Turing Award lecture 'Reflections on Trusting Trust' to demonstrate supply chain security risks.
Analyzes how C and C++ compilers' handling of undefined behavior prioritizes performance, often at the cost of program correctness and predictability.
Explains statistical sampling using a Go program example to estimate population percentages, highlighting its power and practical limits in tech contexts.
Examines the risks and complexities of modern software dependencies, arguing that easy reuse has outpaced our understanding of best practices.
Explores software engineering as programming integrated over time and with other programmers, using Go's design decisions as examples.
A reflection on the non-dogmatic, engineering-based decision-making process in Go language design, contrasting it with user debates.
A screencast and guide introducing the Acme text editor, its minimalist text-based UI, and how programmers can use it.
Explores the minimum number of AND/OR operators needed to express any Boolean function of five variables, detailing the computational approach.
Explains how to create a self-reproducing zip file that contains itself, drawing parallels to self-replicating programs.
An explanation of UTF-8 encoding, detailing its design, convenient properties, and why it's simpler than often perceived.
