-
Code Archaeology: How to Read Code No One Remembers
Read legacy code like an archaeologist: stratigraphy, typology, epigraphy, and excavation discipline reconstruct the forgotten history, constraints, and incidents behind every line of code.
-
Every Stack Is Innocent: A Differential Diagnosis of the Hung Program
A hung program is a measurement, not a mechanism. This article differentiates five causes of zero progress — deadlock, lost wakeup, livelock, starvation, and phantom hang — through a three-layer triage of CPU, thread state, and wait channel, and an investigation method that reasons before it collects evidence.
-
Heap Corruption Forensics: The Crash Site Is Not the Crime Scene
When a heap corrupts, the code on the crash stack is usually the victim, not the killer. A forensics handbook for heap bugs: fill-pattern fingerprints, wound morphology, data-breakpoint stakeouts, and PageHeap — working backwards from the crash site to the crime scene.
-
Non-Invasive Probes: How ASan/TSan/UBSan Expose Bugs Before They Ever Misbehave
How ASan, TSan, and UBSan prove bugs exist before they ever misbehave—by making the assertion behind detection independent of the very variable being disturbed.
-
“It Works on My Machine”: A Complete Taxonomy of Environment Differences
“Works on my machine” isn’t an excuse–it’s testimony: the bug is environment-coupled. A five-layer taxonomy of environment differences (dependencies, toolchain, system interfaces, hardware, outside world), each with its fingerprint, plus differential experiments, a fingerprint script, and snowflakes-to-cattle prevention.
-
What Is Debugging, Really?
Debugging is more than fixing errors; it is the process of restoring the causal link between human intent and machine behavior. This article traces how debugging has evolved with system complexity, examines modern challenges, and argues that AI can assist but cannot replace the engineer’s judgment.
-
Your Codebase Is Drifting Toward Heat Death: The Physics of Technical Debt, and the Engineer as a Source of Negentropy
Technical debt isn’t debt—it’s entropy. Untouched systems rot anyway; order is a flow, not a stock; refactoring can only relocate complexity, never destroy it. The engineer is the one who keeps injecting negentropy.
-
How Git Workflow Changes in the AI Era: When Code Is No Longer “Typed Line by Line”
AI coding assistants have made code production an order of magnitude faster, yet most Git workflows still assume code is written by humans. This article argues that Git workflow must evolve from “recording code written by humans” to “recording code verified by humans.” It explores three shifts: commit granularity should be measured by verifiable intention…
-
The Harder You Look, the Less It’s There: Heisenbugs and the Observer Effect in Debugging
A bug that vanishes the moment you observe it isn’t bad luck–your observation is rewriting the result. This piece breaks down the four root-cause families of Heisenbugs, explains why traditional debugging is structurally doomed against them, and shows how to shift from “real-time intervention” to “post-mortem non-invasive forensics.”
-
Bugs Written by AI Look Like Correct Code: An Epistemic Rewrite of Debugging
For decades, every debugging methodology has rested on an assumption nobody ever said out loud: behind every line of code stands a person who knows why it exists. The assumption is so natural that nobody thinks of it as an assumption. You open an unfamiliar function and by default trust that the naming reflects intent,…