In this story, we will uncover how linked lists were first used to solve data structure challenges posed by simple arrays of data. Let’s begin.

Prologue: A Problem Without Order

It was the early 1950s, and computers were still massive rooms of vacuum tubes and punch cards. One of the most pressing challenges was dynamic memory management—how to store a collection of items when the size of that collection could change during execution. Early machines like the ENIAC and the Manchester Mark 1 used fixed‑size arrays; every element occupied a predetermined slot in memory. If a program needed more space than it had reserved, it either crashed or wasted precious memory.

Enter a young computer scientist named Allen Newell (later joined by Herbert A. Simon) at the RAND Corporation. They were working on a program to simulate human problem‑solving, a project that would eventually become the Logic Theory Machine. Their algorithm needed to keep track of an ever‑growing list of logical statements, but they could not predict how many statements would be generated at runtime.

Chapter 1: The Insight

While sketching ideas on a napkin, Newell imagined a chain of boxes, each holding a piece of data and a pointer to the next box. “If each box knows where the next one lives,” he mused, “we can add a new box anywhere without moving the existing ones.” The concept was simple: instead of a contiguous block of memory, the data structure would be a series of nodes linked together by addresses.

He showed the idea to his colleague Clifford Shaw, who was also wrestling with dynamic data in his own work on early artificial intelligence programs. Together they refined the notion: each node would contain two fields—data (the actual value) and link (the address of the next node). The first node would be called the head, and the last node would point to a special null value indicating the end of the chain.

Chapter 2: The First Implementation

In 1955, Newell, Shaw, and Simon wrote a program for the RAND “Logic Theory Machine” that used this chain of nodes to store theorems as they were derived. Because the number of theorems could not be known ahead of time, the linked list allowed the program to allocate a new node whenever a new theorem was proved, linking it to the previous one. Deleting a theorem was equally straightforward: adjust the link of the preceding node to skip over the unwanted node.

Their code, written in assembly for the IBM 704, looked roughly like this (simplified for illustration):

ALLOCATE NEW NODE
STORE THEOREM IN NODE.DATA
SET NODE.LINK = NULL
IF LIST IS EMPTY THEN
    HEAD = NODE
ELSE
    LAST.LINK = NODE
END IF
LAST = NODE

The elegance of the solution lay in its O(1) insertion at the tail and O(n) traversal when searching—exactly the trade‑off they needed.

Chapter 3: Publication and Spread

Newell and Simon published their findings in a 1956 paper titled “A Logic Theory Machine”. Although the primary focus was on automated theorem proving, reviewers noted the novel data structure. The term “linked list” did not appear yet; the authors referred to it as a “chain of records”.

Around the same time, Donald Knuth, then a graduate student, encountered the idea while working on his Ph.D. thesis on sorting algorithms. He formalized the terminology, coining the phrase “linked list” in his seminal 1968 book "The Art of Computer Programming". Knuth’s clear exposition helped spread the concept throughout the emerging computer science community.

Chapter 4: Why the Linked List Mattered

The linked list solved a fundamental limitation of early computers:

• Dynamic Size: Nodes could be added or removed without reallocating a whole block of memory.

• Efficient Insertions/Deletions: Changing the list required only updating a couple of pointers, not shifting large swaths of data.

• Memory Utilization: Unused memory could be reclaimed by freeing individual nodes, a crucial advantage when memory was measured in kilobytes. These properties made linked lists the backbone of many early operating systems (process control blocks, file allocation tables) and later data structures such as stacks, queues, and even more complex trees.

Epilogue: The Chain Continues

From that modest chain of nodes in a 1950s logic‑theory program, linked lists have grown into a foundational concept taught to every first‑year computer science student. Modern languages hide the pointer arithmetic behind elegant abstractions, but the core idea remains unchanged: connect discrete pieces of data with references, forming a flexible, extensible chain.

So the next time you push an item onto a stack or traverse a singly‑linked list in Python, remember that you’re walking the same mental path that Allen Newell and his colleagues forged half a century ago—link by link, node by node, building ever‑larger structures from the simplest of connections.

Bye 🙋‍♂️

Congratulations! You finished reading this article.
See you then, in another story.

References

• Archive.org - The Logic Theory Machine (Jul 1956)

• Wikipedia - The Art of Computer Programming

Disclaimer: Information used here are obtained from public domain. They are fact-checked and verified.
The images in this article are intended for illustrative purposes only.

In this story, we will uncover how arrays were first employed to tackle data structure challenges at the hardware level. We will also follow their journey as they became crucial elements of programming languages. Let’s begin.

Prologue: A Need for Order

It was the spring of 1945 at the Moore School of Electrical Engineering in Philadelphia.

A handful of engineers huddled around a chalk‑filled blackboard, wrestling with a bold new idea: a computer that could store both its instructions and its data in the same memory. John von Neumann, fresh from his work on the Manhattan Project, was sketching a diagram of a long row of identical cells, each labeled with a number—0, 1, 2…—and a tiny arrow pointing to the next.

“The machine must be able to fetch any datum directly,” he said, tapping the first cell. “If we give each cell an address, the program can jump straight to it without scanning.”

That simple insight—contiguous, addressable memory—was the seed of the array.

Array in Hardware - The EDVAC Experiment

Later that year, the EDVAC (Electronic Discrete Variable Automatic Computer) began construction.

EDVAC was one of the first stored-program computers that utilized registers to hold temporary data and employed magnetic core memory for efficient storage and retrieval of information. Its designers needed a way to keep track of the intermediate results of a long numerical simulation of ballistic trajectories. For this, the values were stored in magnetic core memory. However, as they dove into this complex task, they encountered a significant challenge: the management of data.

Problem - Data was scattered

Initially, data was scattered across non-contiguous memory locations, resembling fragmented islands in a vast ocean. Programmers relied on individual variables to store each piece of data, which forced them into a daunting juggling act as they monitored memory addresses and sizes. This haphazard approach not only complicated coding but also increased the chances of error, rendering even simple operations cumbersome.

While magnetic core memory offered improvements in speed and reliability over earlier technologies, it did little to alleviate the fundamental issue of fragmented storage. The inefficiencies began to surface, especially when complex calculations required multiple variables. Amidst this chaos, the concept of arrays emerged as a revolutionary solution.

Solution - Data stored in arrays of memory

Arrays allowed for contiguous memory allocation, organizing related data into neat blocks. This structural change transformed how EDVAC handled information, making it easier for programmers to access entire datasets at once. No longer did they need to hop between scattered variables; data management became streamlined and intuitive.

This pivotal transition not only resolved the inefficiencies of the early design but also set the stage for future advancements in computing. With the advent of arrays, EDVAC embraced a new era of organized data handling, laying the groundwork for modern programming practices. The struggles of its early days faded into history, replaced by the promise of efficient and effective data management that continues to shape technology today.

The EDVAC’s successful use of a contiguous block of memory became the first real‑world demonstration that an array could serve as a general‑purpose data container.

From Hardware to Language – FORTRAN’s DIMENSION

A decade later, the IBM 704 was humming in a Boston lab. Scientists needed to solve massive systems of linear equations for nuclear physics research. The existing programming methods forced them to write repetitive code for each variable, a nightmare of bookkeeping.

Enter a small team led by John Backus. While drafting the language specification for what would become FORTRAN I, Backus remembered the EDVAC’s memory layout. He introduced the DIMENSION statement:

DIMENSION X(100), Y(100)

Now a programmer could declare a fixed‑size, one‑dimensional array of 100 elements with a single line of code. The compiler translated X(I) into base address of X + (I‑1) times the word size, exactly the addressing scheme pioneered on the EDVAC.

The first FORTRAN program to use DIMENSION solved a set of differential equations for a weather‑prediction model. It ran orders of magnitude faster than its predecessor because the array allowed the algorithm to iterate over data with simple, predictable memory accesses.

Zero‑Based Indexing – ALGOL 60

Across the Atlantic, a consortium of European and American computer scientists gathered in 1960 to design a language that could express algorithms clearly. Their meetings produced ALGOL 60, which introduced zero‑based indexing for arrays:

integer A[0:9];

The decision to start counting at zero mirrored the way hardware addressed memory—offset 0 from the base address. This subtle change made the mental model of array element = base + index × size exact, eliminating the off‑by‑one adjustments that had plagued earlier code.

ALGOL’s array syntax spread quickly to academic circles, influencing later languages such as Pascal, C, and ultimately the modern programming ecosystem.

Epilogue: The Legacy of a Simple Row

From a chalkboard sketch in 1945 to a language keyword in 1957 and a standardized indexing rule in 1960, the array traveled from hardware necessity to a universal programming abstraction. Its core idea—store a collection of homogeneous items in a contiguous block and address each by its position—remains unchanged in today’s GPUs, databases, and high‑performance scientific codes.

Every time a program accesses arr[i], it echoes the same principle that von Neumann first wrote on that blackboard:

… give each piece of data a number, and you can reach it instantly.

The story of the array is a reminder that some of the most powerful tools in computing begin with the simplest of insights.

Bye 🙋‍♂️

Congratulations! You finished reading this article.
See you then, in another story.

References

• Wikipedia - EDVAC

• Wikipedia - FORTRAN

• Wikipedia - ALGOL 60

Disclaimer: Information used here are obtained from public domain. They are fact-checked and verified.
The images in this article are intended for illustrative purposes only.