I rebuilt three small programmes against a recent weekly snapshot today. Two compiled after mechanical fixes. The third exposed an assumption in my own package layout. That ratio feels like progress: the road to Go 1 is becoming less about chasing syntax and more about discovering what code actually depends upon.

I keep a tiny record beside each experiment:

snapshot: release.rNN from the weekly series
compiler: gc
system: linux/amd64
result: build, test, benchmark

rNN here is a placeholder for the precise release printed by the toolchain, not a new version naming proposal. Recording it prevents a December result from quietly becoming a claim about whichever snapshot happens to be current in January.

My surprise was a benchmark that improved after migration even though I had not optimized the programme. The toolchain and runtime are changing alongside the source interfaces. A source diff alone therefore cannot explain every performance change between snapshots. Rebuilding the old source with the old toolchain and the migrated source with the new one changes two variables at once.

For correctness, the weekly process is straightforward. The compiler checks the current language. gofix handles recognized source transformations. Formatting normalizes rewritten code. Tests then check the semantic assumptions neither compiler nor fixer can know. Each layer catches a different class of mistake.

Performance needs a stricter comparison. I preserve the old binary and input, warm up the machine, and run enough iterations to see variation. Linux 3.0, the scheduler, the garbage collector, and compiler output can all affect the number. One fast run is a pleasant event, not a conclusion.

I prefer following named snapshots during this final stretch because each migration stays small and attributable. Waiting for Go 1 might sound safer, but it accumulates every incompatible change into one rather theatrical weekend. The caveat is that preview code remains preview code. I keep important production builds pinned and use copies for migration practice.

The compatibility goal is the larger prize. Once Go 1 arrives, source written to its specification and standard packages should not require this weekly dance merely to remain source-compatible. Implementations can still become faster, schedulers can change, and bugs can be fixed. Stability is a promise about the platform, not the end of engineering.

For now, I will continue writing down the snapshot number. Future me is a notoriously unreliable eyewitness.