Apple’s resource compiler patched machine code while its linker fix waited nine months
Andy Hertzfeld’s recollection exposes the fragile workaround behind early Macintosh development tools, and the engineer who finally made it unnecessary.

Three Macintosh developers hit the same 32 KB code limit in March 1983. Andy Hertzfeld had assumed an application could live inside one code segment. The applications had other ideas (how inconsiderate).
His first-person account describes the escape route: divide programs into segments and let the resource system load them. A jump table connected calls between segments. The complication was the Lisa linker that produced the code, which expected ten-byte entries where the Mac needed eight.
That difference mattered every time one segment called another. An address calculated for ten-byte spaces lands in the wrong place when the spaces are eight bytes wide. Think of a row of numbered mailboxes: narrowing every box changes where the later numbers sit, even though the numbers themselves look reassuringly familiar.
Hertzfeld requested a linker change and couldn’t get its source. He instead taught RMaker to recognize certain instructions and adjust their references. Calling it “a wild hack” was his assessment, which seems fair for a resource-building tool that had also acquired the job of repairing another tool’s machine code.
The dangerous detail deserves to stay attached to the clever one. RMaker couldn’t reliably distinguish executable instructions from inline data. A pattern that looked right could be the wrong thing to change. Hertzfeld reports no failure known to him; that gives us a recollection of success with a stated blind spot, rather than a proof that the scanner was safe.
The account says the workaround lasted more than nine months. After the responsible linker engineer moved projects, Barry Haynes made the requested change within days. Hertzfeld could remove the scanner in March 1984. The byte-saving trick had been temporary on paper and seasonal in practice.
For anyone who keeps aging build tools alive, the useful question is whether a patch consumes an explicit format or merely recognizes something that resembles one. Those choices can produce identical output for a long time. They deserve different levels of confidence, particularly when the producer can change independently.
A practical review would start with the exact references the patch edits and an example of data it must leave alone. It would also name the upstream change that makes the patch obsolete. Otherwise, every future maintainer inherits both the workaround and the archaeology needed to understand it.
A fixed linker removes the need to guess which bytes deserve repair. That is a much nicer development environment than asking every new application to remain lucky. The people waiting for their programs to grow had no way to know which would arrive first: the real fix, or a troublesome byte pattern.
Haynes finally closed the jump.