Stone Age Computing

Chronicles of Computation — The Early Mechanisms

“All things are numbers.”
— Plato, as quoted by his student, Aristotle in “Metaphysics”, around 350 BCE.

In the vast expanse of human history, the story of computation begins not with silicon and electricity, but with bone and notches. The earliest known tools used for calculation were simple and crude, yet they marked the dawn of mathematical thought and set the stage for the complex software systems we engineer today.

Our journey begins in the Paleolithic era, a time when early Homo sapiens roamed the earth. These early humans, our ancestors, were not merely survivalists, but also innovators and problem solvers. They used what was available in their environment to create tools, not only for hunting and gathering but also for abstract tasks like counting and recording data. One such tool was the tally stick.

Photo by Martijn Vonk on Unsplash

Tally sticks were essentially bones or pieces of wood with notches carved into them. Each notch represented a unit of something — a day, a completed task, a traded good. The notches were a physical manifestation of an abstract concept: the idea of quantity. This was a significant cognitive leap, the birth of numerical abstraction.

# A simple Python representation of a tally stick
class TallyStick:
    def __init__(self):
        self.notches = []

    def add_notch(self):
        self.notches.append("|")
        self.print_notches()

    def print_notches(self):
        print("".join(self.notches))

    def count_notches(self):
        return len(self.notches)
    
# Create a tally stick
my_tally_stick = TallyStick()

# Add ten notches
for _ in range(10):
    my_tally_stick.add_notch()

# Count notches
print("The tally stick has "
      f"{my_tally_stick.count_notches()} notches.")

This Python code represents a tally stick as an object with a property notches. The add_notch method adds a notch and prints the current notches. The count_notches method returns the current count. This is a simple example of how we can use code to represent and manipulate abstract concepts, much like our ancestors did with tally sticks.

Save the previous file as my_tally_stick.py and run it using Python. Here’s the output:

|
||
|||
||||
|||||
||||||
|||||||
||||||||
|||||||||
||||||||||
The tally stick has 10 notches.

Try again, changing the number of notches or the character used to represent a notch.

Our next stop is the Lebombo Mountains, located between South Africa and Swaziland, where the Lebombo Bone was discovered. This baboon fibula, dated to approximately 35,000 BCE, is engraved with 29 distinct notches and is believed to be the oldest known mathematical artifact. It’s speculated that it might have been used as a lunar phase counter, marking a monthly cycle.

We then travel north to the banks of the Semliki River in the Democratic Republic of Congo. Here, in the 1960s, a remarkable artifact known as the Ishango Bone was discovered. This bone, dated to around 20,000 BCE, from a baboon’s thigh, is etched with a series of notches arranged in three columns. The notches aren’t random; they seem to follow a certain mathematical logic, with patterns of prime numbers and relationships that hint at an understanding of multiplication and division.

# Python representation of the Ishango Bone
class IshangoBone:
    def __init__(self):
        self.columns = [[], [], []]

    def add_notch(self, column):
        self.columns[column].append('|')

    def print_notches(self,column):
        notches = "".join(self.columns[column])
        print(f"Column {column+1} {notches}")

    def count_notches(self, column):
        return len(self.columns[column])

# Create an Ishango Bone
my_ishango_bone = IshangoBone()

# Add notches to the columns
for _ in range(11):
    my_ishango_bone.add_notch(0)
for _ in range(13):
    my_ishango_bone.add_notch(1)
for _ in range(17):
    my_ishango_bone.add_notch(2)

# Print notches in the columns
for i in range(3):
    my_ishango_bone.print_notches(i)

# Count notches in the columns
for i in range(3):
    print(f"Column {i+1} has "
          f"{my_ishango_bone.count_notches(i)} notches.")

This Python code represents the Ishango Bone as an object with a property columns, which is a list of three lists. Each list represents a column on the bone, and each item in the list represents a notch. The add_notch method adds a notch to a specified column, and the count_notches method returns the current count of notches in a specified column.

Save the previous file as ishango_bone.py and run it using Python. Here’s the output:

Column 1 |||||||||||
Column 2 |||||||||||||
Column 3 |||||||||||||||||
Column 1 has 11 notches.
Column 2 has 13 notches.
Column 3 has 17 notches.

Try again, changing the number of notches or columns, or using a different character to represent a notch.

Despite the simplicity of these early computational tools, they represent a profound shift in human cognition: the ability to abstract quantities and perform calculations. This is a foundation upon which all of mathematics (first) and software engineering (then) is built.

The recent research suggests that the bone’s notches might be more than just a simple tally. The patterns of the notches suggest a sophisticated understanding of number systems and may even indicate knowledge of the base-12 system. This discovery challenges our understanding of the history of mathematics and computation. Maybe our ancestors were capable of complex mathematical thought far earlier than previously believed.

As we delve deeper into the history of software engineering, we’ll see that this spirit of innovation and problem-solving is a common thread that runs through the entire discipline. From the earliest tally sticks to the most advanced AI systems, software engineering is fundamentally about using abstraction and logic to solve problems. And as we’ll see next, this has led to some of the most remarkable achievements in human history.

This story is part of the Chronicles of Computation book. The next section is Sumerian Numerals.