Aeolipile: a steam engine from 2000 BC
Issue #8: Programming History

A Brief And Painful History Of Programming

Kent Beck is deservedly famous for creating Test-Driven Development (TDD.) According to himself, he did not invent it. He only rediscovered it.

Beck found about this forgotten TDD technique while chatting with an older programmer. The elder explained how things were done back in the good ol’ days of punch cards:

10: Grab a punchcard, and manually punch the output you need.
20: Start coding. Every time the mainframe spits a punchcard, compare it to the one you manually punched.
30: If both cards match, GOTO home. Otherwise, GOTO 20.

The elder sage was baffled to know that this was not a common practice anymore:

Then how on Earth do you know that your code is correct?

Great question, grandpa!

Alchemists, At Best

There is a surprising amount of ideas and concepts that have been forgotten and rediscovered along our short history. This is a clear telltale that even though Computer Science is a science, programming is not. Neither is it a form of engineering. We are neither scientists nor engineers, alchemists at best.

The history of programming resembles the history of science until the Renaissance. A painful process of back and forth where each individual had no giants on whose shoulders to stand, or had forgotten them.

There’s a plethora of breakthroughs that disappeared into the sands:

  • Hero of Alexandria built steam engines and wind-powered machinery 2000 years before the industrial revolution.
  • Aristarchus of Samos first suggested Heliocentrism in the 3rd century BC.

And the list sadly goes on.

Our Own Heroes

We have our fair share of programming Heroes and Aristarchuses.  Lisp is perhaps the most obvious one, but there are many others. To name an few:

Daniel McCracken mentions TDD using punchcards in his book “Digital Computer Programming“, in 1957. As of today, more than half a century later, it’s still not a standard practice in the average software shop.

Edward Ashroft and others first described the data-flow programming paradigm. They designed an entire programming language around this concept, called Lucid in the early 80’s. Only now these ideas are being rediscovered as a better solution for data-intensive apps. is now using workflows of data as a better alternative to microservices.

Ralph Griswold

Perhaps the most undeservedly forgotten of these Heroes was Ralph Griswold. At the University of Arizona, in the early 70’s, he created two amazing languages: Snobol and Icon.

Learning about Snobol is like finding the remains of an ultra-advanced alien civilization while digging in your backyard.

Back in the 70’s, when there were people walking around the Moon and you could buy a ticket for a supersonic commercial jet, you also had a language with delayed evaluation, pattern matching and many features not yet found in “modern” languages.

One of the key insights Griswold and his team had, was deceptively simple:

When a function is called, only two things may happen: It either succeeds or fails.

Every function in Snobol or Icon either fails or succeeds. This information is returned for every function and is orthogonal to the return value. Having success and failure as first-class citizens of the language greatly simplifies error handling. It also allows for very flexible control-flow and even concurrency via coroutines. Only now (forty years later!) are some of those concepts entering the mainstream via the Result type that the “modern” kids on the block have or coroutines (very few have).

This evolutionary process, slow and painful, where information is lost, hopefully to be rediscovered later, could be described in terms of the Myth of Sysiphus. However, Philip Greenspun did a much better job at describing it:

Our industry is a constant source of embarrassment.

What Is Dead May Never Die

If an elegant idea is carried away by the hype tide du jour, fear not. If this has been coded before, it will be coded again. So say we all!

To the memory of Ralph E. Griswold (1934 -2006.)

Cover image by the author: Aeolipile, a steam engine from 2000 BC.