One of the core parts of any computer, from any era, is some form of data storage. Exactly how this is implemented and exposed to the programmer has changed a lot over the history of computing engines.

Perhaps the most influential idea in designing computing engines is the Von Neumann Architecture. This was proposed in John von Neumann’s 1945 paper, First Draft of a Report on the EDVAC. In such an architecture, both the program and its data are stored in the same way. This is a logical extension of Alan Turing’s ideas - that programs are just another form of data - in the context of a real implementation.

Sequential Stores
The first form of data storage found in early computers was the Williams Tube. At the core of the device was a cathode ray tube. When the electron beam hits the front of the tube in such a device, it becomes negatively charged. This charge can be read by a plate on the front. The action of reading a value also destroyed it. Williams Tubes were used in some of the first stored program computers, but were unreliable and degraded over time making them unpopular in commercial use.

The Mercury Delay Line was developed at around the same time and became more popular. The idea of a delay line is that an electrical wave is turned into a sound wave at one end. It then propagates along the medium (initially mercury) and is turned back into an electrical signal at the far end. The speed of sound in mercury is much lower than the speed of an electrical signal in a wire. This means that a loop can be set up where data is constantly read from one end of the line and written back to the other end.

Mercury delay lines were eventually replaced by other forms of delay line such as magnetostrictive delay lines, which used magnetism to induce a twist into one end of a wire which would propagate along its length.

The key attribute of these storage systems is that they are intrinsically sequential. Data are written into one end of a delay line and can not be accessed until they reach the other end.

Registers and Cache
In spite of their limitations, delay lines remained popular for some time. Small numbers of very short delay lines were used to augment slower memory systems. In some later machines, these were not directly visible to the programmer. These were termed ‘cache,’ from the French meaning ‘to hide.’ When a location in slower memory was accessed, it and the surrounding region would be loaded into the cache (hidden) memory in a block.

In modern computers, cache is typically implemented using static RAM, however we still retain the terminology from this era and refer to a block of cache memory loaded in one go as a cache line.

Delay lines were also used in early computers as registers. A register is a storage location capable of storing a machine word which is considered close to the processing elements. Arithmetic and other operations can be performed directly on values stored in registers.

Random Access Memory
A lot of early programming depended on arranging accesses (see Optimal Programming). Modern memory is known as random access memory (RAM) because access times do not depend on the location in the storage. Accessing a word from memory takes the same amount of time irrespective of where it is.

One of the earliest forms of RAM was magnetic core memory (also known as ferrite core memory). This worked by having a regular grid of wires with discs of iron around each intersection. Placing a current through a pair of wires will magnetise the core in one direction or the other depending on the direction of the current.

In and Out of Core
Magnetic code memory was often used in conjunction with a larger store, such as winchester disks or magnetic tapes. These were collectively known as out-of-core storage, to distinguish them from in-core storage (data resident in the magnetic cores).

The principal difference between in-core and out-of-core data is how a program accessed it. Typically, a programmer loaded data from core memory to registers using LOAD instructions and returned it using STORE instructions. On some systems, operations could be performed directly on data in magnetic core storage. External storage could not be accessed directly. Before computing on data stored out of core the operating system had to load it into the core.

This terminology persists today. Modern operating systems often swap data out of main memory onto a hard disk. On UNIX systems, the mincore() system call (short for memory in core) is used to determine whether a bit of data is currently resident in memory. When a UNIX program crashes, it dumps a copy of its memory to a file with a .core extension, known as a ‘core dump,’ since early systems would have written out the contents of their magnetic core storage for offline debugging. Fortunately, modern programmers are able to use high-level tools to examine their core dumps and don’t have to read through pages of printouts.

Further Reading: John von Neumann’s First Draft of a Report on the EDVAC