The physical weaving of binary code into core rope memory for the Apollo Guidance Computer (AGC) is one of the most fascinating intersections of advanced aerospace engineering and traditional human craftsmanship. In the 1960s, long before the invention of modern flash drives or solid-state memory, the software that safely guided the Apollo astronauts to the Moon and back was literally sewn together by hand.
Here is a detailed explanation of how this unique technology worked and the women who built it.
1. The Problem: The Need for Indestructible Memory
In the 1960s, computer memory was large, fragile, and prone to failure. The Apollo Guidance Computer (developed by the MIT Instrumentation Laboratory) required memory that was: * Extremely dense: It had to store complex navigational software in a very small physical space. * Indestructible: It had to survive the intense vibrations of a Saturn V rocket launch. * Radiation-hardened: It had to be immune to cosmic rays in deep space, which could easily flip the magnetic bits of standard computer memory, causing catastrophic software crashes.
The solution was Core Rope Memory, a type of Read-Only Memory (ROM) where the software was physically hardwired into the machine.
2. The Technical Concept: How Thread Became Binary Code
Core rope memory utilized tiny, donut-shaped rings of magnetic metal called ferrite cores. To store the software, conductive copper wire was woven around and through these cores.
The binary system (1s and 0s) was dictated entirely by physical placement: * Logical "1": If a wire passed through the center of a magnetic core, it represented a 1. When a current was sent through the core, the wire would pick up a signal. * Logical "0": If a wire bypassed the core and was routed around the outside of it, it represented a 0. No signal would be picked up.
Because a single ferrite core could have dozens of wires passing through or around it, the data density was incredibly high for the era. Once the wire was woven, the software was completely permanent. It could not be erased, altered by cosmic radiation, or deleted by a power failure. The software literally became hardware.
3. The Weavers: The "Little Old Ladies"
MIT engineers could write the code, but they lacked the manual dexterity and patience to physically assemble the memory modules. To build the memory, the subcontractor Raytheon hired skilled female textile workers, seamstresses, and watchmakers from the local New England area.
These women possessed immense hand-eye coordination and were accustomed to doing highly precise, repetitive work for hours at a time. The engineers colloquially referred to the finished product as "LOL Memory," which stood for "Little Old Lady" memory (though many of the women doing the work were actually quite young).
4. The Weaving Process
The process of weaving the memory was not entirely unguided; it was a hybrid of automation and intense manual labor.
- The Code: Programmers, led by software engineering pioneer Margaret Hamilton, would write the navigational code. This code was translated onto punched cards.
- The Machine: The punched cards were fed into an automated positioning machine. The weaver sat at this machine with a large matrix of ferrite cores in front of her.
- The Action: The machine would read the punch card and automatically move a metal guide to the correct ferrite core. The weaver held a hollow needle attached to a spool of fine copper wire.
- The Threading: If the code called for a "1," the machine positioned the guide so the weaver would pass her needle through the core. If it called for a "0," the machine positioned the guide so she would pass the needle around the core.
- Verification: The process was incredibly tedious. A single module took weeks to weave. If a worker put a wire through a hole instead of around it, it was a software bug. Therefore, the system had electrical tests built in. If the worker made a mistake, the machine would halt, and she would have to painstakingly un-thread the wire back to the error and fix it.
The Legacy of Core Rope Memory
By utilizing core rope memory, the AGC was able to store about 72 kilobytes of ROM—a staggering amount for a computer of its size at the time.
Because the manufacturing process took so long, the software had to be completely finished, tested, and frozen months before a launch. There was no such thing as a "day-one patch" in the Apollo program; once the women at Raytheon snipped the final wires and the modules were sealed in protective plastic, the code was literally set in stone.
The success of the Apollo moon landings relied heavily on the meticulous, unseen labor of these textile workers. They took the mathematical brilliance of MIT programmers and, stitch by stitch, wove it into the physical reality that brought humanity to the Moon.