RAM: The Forgotten History (2024)

We often credit the birth of computing to Charles Babbage, but the true catalyst was actually the creation of electronically-controlled working memory.

In a previous 2023 piece regarding the evolution of calculators, I expressed frustration with how computer history is typically taught.

I believe we give far too much credit to Charles Babbage overemphasize Babbage's role. Mechanical calculators had existed since the 17th century, and the theory of programmable machines was well-established long before his time. The real obstacle was physical: once a machine reached a certain complexity, using cams and sprockets to move data became impossibly cumbersome.

The actual "eureka" moment was the electronically-controlled data register. These circuits allowed data to be "locked" and routed efficiently, regardless of the machine's scale. This history of "working memory" is frequently overshadowed by the history of bulk storage or I/O, yet RAM limitations were the primary bottleneck for personal computing until the late 1990s.

---

The Bistable Cell

The earliest practical implementation of electronic memory was the relay—essentially an electromagnetically actuated mechanical switch.

How Relays Work

A relay's action can be:

1. Momentary: Active only while powered.
2. Sustained (Latching): Stays "on" until a reset coil is triggered.

By wiring a momentary relay to supply its own power once closed, you create a memory bit.

The Logic Flow:

• Pressing set $\rightarrow$ Energizes relay $\rightarrow$ Closes parallel switch.
• The circuit remains powered even after set is released.
• Pressing the Normally-Closed (NC) reset button $\rightarrow$ Interrupts current $\rightarrow$ Unlatches.

The Zuse Z3

Konrad Zuse utilized relay-based memory in the Z3, likely the first true electronic computer.

However, relays are slow (switching at only tens of hertz). Zuse knew this was a dead end, but he used the technology to try and secure funding from the Nazi regime. Fortunately for Europe, the regime was unimpressed, and the funding never materialized.

---

The Shift to Vacuum Tubes

While Zuse struggled, Allied codebreakers funded more expensive vacuum tube designs. William Eccles and Frank Wilfred Jordan proposed a bistable circuit to replace the clunky relay.

This circuit uses a transformer winding to trigger a self-reinforcing feedback loop between tubes, effectively creating a "latch."

Understanding the SR Latch

Both the relay and the tube circuits are known as Set-Reset (SR) latches. This is the same fundamental logic used in modern SRAM (Static RAM) found in CPUs today.

Logic Analysis:

• If reset is high: The AND gate is forced to 0, regardless of the OR gate.
• If reset is low: The AND gate simply passes the OR gate's value.
• If set is high: The OR gate outputs 1.
• If $S = 0$ and $R = 0$: The device is latched, holding the previous value via the feedback loop.

---

The Cost Crisis

Despite their speed, vacuum tubes were impractical for bulk memory.

Because of these constraints, engineers had to find a different way to handle main memory until Large-Scale Integration (LSI) arrived in the mid-70s.

---

The "Merry-Go-Round" (Dynamic Memory)

The alternative was dynamic memory, which used transient physical phenomena (like acoustics or static electricity) to store data. Because these states decay, the data must be constantly refreshed.

The Atanasoff-Berry Computer (ABC)

The ABC was a non-programmable calculator that used a rotating drum equipped with mechanically-switched capacitors.

• Mechanism: Digital info was stored as a charge in a capacitor.
• Problem: Capacitors leak charge (self-discharge).
• Solution: Regular refresh cycles.

This was the direct ancestor of modern DRAM, which still utilizes capacitors in our phones and PCs today.

Summary of Memory Evolution

• Electromechanical Relays (Z3)
• Vacuum Tube Bistable Cells (Eccles/Jordan)
• Capacitor-based Drums (ABC)
• Modern SRAM/DRAM

# Conceptual representation of a Latch state
class SRLatch:
    def __init__(self):
        self.state = 0

    def update(self, S, R):
        if R == 1:
            self.state = 0
        elif S == 1:
            self.state = 1
        # If S=0 and R=0, self.state remains unchanged (latched)
        return self.state