Did You Know the ENIAC Was Programmed by Physically Rewiring It?

The ENIAC: A Machine That Was Literally Wired to Compute

When we think of programming today, we imagine typing code into an editor, compiling it, and running it on a machine. But the first general-purpose electronic computer, the ENIAC (Electronic Numerical Integrator and Computer), had a very different workflow. To program it, engineers and mathematicians had to physically rewire the machine like a giant telephone switchboard.

The Birth of the ENIAC

The ENIAC was developed during World War II at the University of Pennsylvania. It was designed to calculate artillery firing tables for the U.S. Army. Completed in 1945, it was a massive machine: it occupied 1,800 square feet, weighed 30 tons, and contained over 17,000 vacuum tubes. But what set it apart from earlier electromechanical computers was its programmability — though the term "programming" meant something quite different then.

Programming via Patch Cables and Switches

Unlike modern computers that store programs in memory, the ENIAC had no stored-program concept. Instead, to set up a calculation, operators had to physically connect its various units — such as accumulators, multipliers, and function tables — by plugging patch cables into a patch panel, similar to a telephone switchboard. They also set function table switches to specify constants and instructions.

This process was incredibly labor-intensive. For each new problem, a team of operators, often women known as "computers," would manually reconfigure the ENIAC's wiring. A typical job could take days or even weeks to set up. The ENIAC's configurability was essentially a large collection of hard-wired programs that could be altered only by changing the physical connections.

The Women Who Programmed the ENIAC

The ENIAC's first programmers were six women: Kay McNulty, Betty Jennings, Betty Snyder, Marlyn Meltzer, Fran Bilas, and Ruth Lichterman. They were mathematically trained and tasked with figuring out how to program the machine — a task for which there was no manual. They developed the first programming techniques, including subroutines and loops, all through physical rewiring. Although their contributions were largely unrecognized for decades, they are now celebrated as pioneers of computer science.

The Shift to Stored-Program Computers

The ENIAC's manual rewiring approach was powerful but impractical. It led directly to the concept of the stored-program computer, famously articulated by John von Neumann in his 1945 report. By storing both instructions and data in memory, a computer could be reprogrammed quickly without physical changes. This architecture, known as the von Neumann architecture, became the foundation of virtually all modern computers.

Today, the ENIAC's legacy endures in the flexibility of software. Instead of rewiring, we write code, compile it into binary, and load it into memory — a process that happens in milliseconds.

Lessons for Modern Developers

Programming by rewiring might seem archaic, but it offers two important lessons:

1. Abstraction is powerful. The ability to write high-level code that is translated into machine instructions is a direct descendant of the ENIAC's physical programming. Each layer of abstraction (assembly, C, Python, etc.) has made computing more accessible.
2. Hardware and software co-evolve. The ENIAC's limitations drove innovation in computer architecture. Today, understanding hardware constraints remains crucial for optimizing software (e.g., caching, parallel processing).

Practical Example: Simulating ENIAC's Logic with Modern Code

While we can't rewire modern computers physically, we can simulate the ENIAC's approach using a giant switch statement or configuration. Here's a simple example in Python that mimics routing execution based on "patch cables":

# Simulating ENIAC's patch cable programming

def execute_program(instructions):
    # instructions is a list of tuples (unit, operation, input_values)
    accumulators = {}
    for unit, op, values in instructions:
        if unit.startswith('A'):
            # Accumulator unit
            if op == 'add':
                accumulators[unit] = accumulators.get(unit, 0) + sum(values)
            elif op == 'sub':
                accumulators[unit] = accumulators.get(unit, 0) - sum(values)
        elif unit == 'mult':
            # Multiplier unit
            result = 1
            for v in values:
                result *= v
            # Store result in a default accumulator
            accumulators['A0'] = result
    return accumulators

# Example: calculate 5 + 3 * 2
# Rewiring: connect multiplier to multiply [3,2], then accumulator to add [5, result]
program = [
    ('mult', 'mult', [3, 2]),
    ('A1', 'add', [5, 'A0'])  # A0 holds result from multiplier
]
result = execute_program(program)
print(result)  # Output: {'A0': 6, 'A1': 11}

This example is simplistic but illustrates the idea of physically connecting units to achieve a computation.

Conclusion

The ENIAC's programming method was a testament to human ingenuity in the era before software. Today, we take for granted the ability to reprogram a computer in seconds. Understanding our history helps us appreciate the flexibility we have—and reminds us that every line of code runs on a physical machine that, at its core, still requires a form of "rewiring" at the transistor level.

For further reading, check out the ENIAC history on Wikipedia and a detailed account of the ENIAC programmers.