Advent of Computing - Episode 1 - Folded Spindled and Mutilated

Episode Date: April 9, 2019

Today, I want to share with you a technology that shambles among us as a corpse that refuses to die. That is, of course, the punch card. In this episode, we will be talking about the storied history and influence from beyond the grave of the punch card.

Do you own any patterned woven fabric? Maybe a comfy woven blanket? Or, if you work in an office like I do, then there's a good chance you own a tie that would fit that description. Let me try asking this another way. Have you ever read any U.S. Census data? Or counted the 80 columns of a computer text display? Or maybe you remember the 2000 US presidential election. If you answered yes to any of the previous questions, then let me be the first to congratulate

you. You've experienced, or in some cases, been cursed by, the power and the legacy of the punched card. Welcome to Advent of Computing, the show that talks about the shocking, intriguing, and all-too-often relevant history of computing. This is Episode 1, Folded, Spindled, and Mutilated. I'm your host, Sean Haas. Today, I want to share with you a technology that shambles among us as a corpse that refuses to die. That is, of course, the punched card.

In this episode, we will be talking about the storied history and influence from beyond the grave of the punched paper card. First off, what exactly is a punch card? First off, what exactly is a punch card? On its simplest level, a punch card is a means of storing data via a series of holes punched out of a paper card. The idea is that the pattern of holes is used to encode data. The data could be anything. A program, accounting records, a picture. What makes it a punch card is really just the way that it's stored on a card of paper. The other part of this definition that's important for us to remember is encoding. That means that a punch card doesn't really store its data directly per se. Instead, it stores some type

of representation of the data. Think of how something like Morse code is able to store letters in terms of dots and dashes, and you'll have a good handle on this concept. The idea of encoding is something that we will come back to as we look at different uses of punch cards. Now that that's out of the way, I think it's time for another question. What do you think is the oldest computer, or at least the earliest step towards computers? In this case, a lot of people would say it's Charles Babbage's analytical engine, a simple mechanical computer designed around 1819. However, I'd argue that an earlier example, or at least an earlier step, exists. That's Basile Bichon's loom, dating all the way back to 1725. Bichon's loom used a set of punched paper cards to

control how it wove textiles. A full pattern was stored on a stack of these paper cards, which were connected together by thread to form a type of tape that was then fed into the loom. Essentially, this functioned as a rudimentary way to store a program. This new loom was made specifically to use a stored procedure to automate the generation of an output, in this case, the weave of textiles. When you get down to the basal level here, that's exactly what any computer is designed to do, just in a highly reduced and highly simplified way. This machine is also where we see an early example of punched paper card being used for long-term data, or in this case, close-to-program storage. or in this case, close to program storage. The later Jacquard loom, popularized by Joseph-Marie Jacquard in 1804,

was a refinement of Bichon's earlier loom. The Jacquard loom was able to weave much more complex patterns. And complex is really the right word to describe these. Some of them are amazing. The best example I can think of is an 1839 portrait of Joseph-Marie Jacquard, the man himself, woven entirely in silk. Roughly 24 by 13 inches, the portrait took some 24,000 punched cards to encode. The detail on this piece is really spectacular. It's easy to mistake it for an etching or even a painting at first glance, but on closer inspection you can clearly see the weave of the silk fabric. This is an

example of early proto-programming, but also highlights a major trait that we'll see come up again and again in punch cards. They're not very information dense. It takes a lot of paper to store any real usable amount of data. The next stop on our tour of paper is in 1890. Now, I'm going to get to the computer part of the punch card story soon enough, but there's a surprising amount of pre-computer use for the punched card. The place that we're stopping at is, of course, the 1890 U.S. Census. The device that used these cards during the census was called the Hallrith Electrical Tabulating Machine. Similarly, the type of card that was designed for use with these machines

was called the Hallrith Punch Card. Personally, I'm kind of on the fence if the Hallrith cards were really that important in the grand scheme of the punch card story. The cards in question were not general-purpose punch cards. Instead, they were laid out more like the form on a standardized test. Later punch cards that we'll be discussing were designed specifically to encode each column as some generic data point, such as a letter or a number. Instead, data on a Hallrith card was laid out in more a jumble of groups of choices

for each census question. For example, a 3x6 grid of options on the punch card was used to specify the country of origin for whoever the census was being taken for. Likewise, the male-female selection on the card was chosen by punching either an M or F hole in another one of the groups. The tabulating machines used to read these cards was also somewhat underwhelming in terms of computing power and generality. Essentially, the tabulator looked like a large wooden desk with a single card reader on the desk's top. The face or back of the desk was covered in a set of dials

that were used to read out the calculations that occurred in the machine. A card would be read by placing it into the single card reader, which, basically think of an Iron Maiden, but for cardstock. The operator would close the card reader, which would drop a set of pins onto the card, one for each possible punched hole. Any pin that hit a punched position would drop through the card and complete an electrical circuit on a plate below the card reader, which would cause the dial for the corresponding group to tick up by one. Basically, the tabulator could only handle running counts. It didn't even produce any real output, since the operator of the machine would have to write down the value on each of the

dials by hand. Despite accomplishing such a simple task, there was a really good reason to use tabulating machines for the census. America at this time was growing, and since a census takes place every 10 years as per the Constitution, that means it's pretty important to be able to finish a census in less than 10 years, otherwise the data you're putting out is just obsolete. The previous census in 1880 took somewhere around 8 years to complete. Tabulating machines helped to expedite calculations, while also removing some part of the human error, mainly just in actually running the sums. Due to this, the 1890 census was completed in just 6 years. All in all, while the tabulating machine is a somewhat single-purpose

and underwhelming device, it was very important to the time and the place it was designed. After some early success with the U.S. Census, Hallrith and a few other tabulating machine manufacturers merged to form a company called the Computing Tabulating Recording Company, more easily called CTR. The company made tabulating machines and punched cards into the 1920s. However, in 1924, CTR changed its name to another three-letter acronym that we're all familiar with. International Business Machines. A quick aside here.

To me, whenever I read about vintage or retro computing, it always kind of spooks me just how old and omnipresent IBM is in just about all computer developments. Now that we've mentioned the big blue elephant in the room, it behooves us to actually talk about it. The next stop on our tour of card stock is, of course, the IBM Punch card and the standardization of the punched card, which is surprisingly still in the pre-computer era. In 1928, IBM introduced a new punched card that could store much more data than earlier cards. The new card had rectangular holes so that holes could be punched more densely. Now a single card had 12 rows and 80 columns, for a grand total of 960 entire holes. The new rectangular holes were also unique enough that IBM could patent and monopolize this punch card, which, really, patents and

monopolization are IBM's real specialized good in the industry. Besides having more data per card, the IBM punch card also introduced a standard for generic data storage that would be used for decades to come. This essentially means that the same punch card could hold accounting data or a letter or source code or even a binary program. The generic data storage required a special type of encoding, which works in what seems like a bizarre way to our modern sensibilities.

For the IBM encoding standard to make any sense, we have to remember that real computers were still a ways off. ENIAC wouldn't be made public for another 21 years. Alan Turing wouldn't even formalize the Turing machine for another eight. What I'm trying to point out here is that there were no real models of computing or how encoding for data on computers would work. Partly this is because punch cards weren't really intended for computer use. Partly this is also because the idea of computer use didn't really exist yet.

What I'm trying to get to here is that there weren't any set standards, so IBM really had to blaze their own path in this regard. With that on the table, let's dive into what an IBM punch card really looks like as far as data encoding. As I mentioned before, the basic layout is a grid of 12 by 80, all of rectangular holes. The top corner on, well, the top left corner of the punch card is clipped to mark it so that there's only one way you can feed it in or out of a machine. The original spec allowed for encoding of numbers, alphabetical characters, and a few special characters. So far, nothing super bizarre, but hang on. This is just the beginning. From top to bottom, the rows are labeled 12, 11, 0, 1, and then all the way back up to 9.

Numbers were encoded by just punching out a hole in the corresponding row 0 through 9, with 12 and 11 being used in that mode for two special characters, usually a slash and an ampersand. Alphabetic characters were encoded using a scheme called zoning. The alphabet was broken up into three zones, with rows 12 through 0 used to specify which zone you were using. For example, the character A is the first character in the first zone, so to encode an A, you would first punch a hole in row 12 to specify the first zone, and then punch row 1 to specify the first position in that zone. Similarly, Z is the last character in the last zone, so it'd punch a row out of zero to specify the last zone, and then punch nine to specify the last character in that

zone, so when that got fed into a machine, it would read a Z. That's the gist of the encoding for the IBM punch cards. numbers are straightforward and letters are a little more confusing and need multiple punches. Later, the standard had to be expanded to more special characters. This was done by adding more and more zones. So, later iterations of the punch card standard with IBM cards would need three, maybe four punches to encode some special characters, like quotes or braces. Binary could also be stored on these cards. In that mode, it was just a matter of punching a hole for a one and leaving a blank for a zero. The card could then just be read as a simple string of binary data. While this is immensely useful and allowed for storage of completed programs or compact data, it isn't

very interesting as far as the strange encoding schemes at play go. The point to all this is that the IBM Punch card brought something very important and long-lasting to the table. That's the idea of generic data storage. This one card could hold essentially any data you could think of. Anything you could represent as numbers and letters could just be encoded using zoning. Anything else could be mixed down to binary data and then put on using binary mode. So, that's all well and good. We now have a standard described and a generalized punch card. But what's the use of all this? Up until the real advent of computers, IBM punch cards were mainly used for

business-oriented number crunching tasks, such as accounting. The machines used in this area were a step up from earlier tabulating machines, but still nowhere near the complexity of modern computers. Three main systems were used with IBM punch cards. The card punch, the card sorter, and the actual accounting machine, usually some kind of complex tabulator or automated calculator. The card punch is, if you want to take a guess here, what's used to actually punch out the punched cards. These machines were essentially a typewriter that was set up to encode and punch data onto cards. Some machines could even be set to type the actual character you're encoding above the column so that a human could easily read what was on the

punched card. Sorting machines were another device that, judging by the name, you can probably guess what they did. Essentially, they would sort the punch cards based off a column value on each card. Some of them could be set to do slightly more complicated operations, but really it was mainly just to do quick passes and simple sorts. The final machine is the real meat of the operation, and this breaks from the tradition set by the earlier card punch and card sort in that the name isn't something that you could easily guess. This whole set of machines that read and operated on punch cards were called unit record equipment. I know, judging by the name, there's something about units, maybe numbers, and there's something

about recording and then equipment, which could mean anything. Basically, all of these devices were just complicated tabulators or calculators, as I mentioned before, that were able to operate on sets of data stored on punch cards. In operation, a stack of punch cards would be loaded. The machine would then read through them and produce some kind of output, either as printed data or on another set of punched cards. Some machines could even add data on each card as they were fed through the system. These devices were controlled by a plug board. Basically a very early form of programming, instead of being built for a single operation like earlier census tabulating machines,

these unit record machines were able to be rewired using a series of pluggable sockets and cables. This allowed operators to change some of the machine's functions by rewiring them in the field. For the most part, this amounted to some simple operations such as summing a set of columns on a stack of cards, or maybe calculating the average of a set. One of the interesting aspects of these early machines was that many plug boards could be swapped out. This meant that once programmed, the entire wiring panel could be removed and stored for later use. In this way, unit record equipment is approaching the stored program computers we are familiar with. That being said, though, these machines were extremely basic,

usually only employing the most basic arithmetic operations. Just a point of order here, these machines were not functional computers and don't think of them that way. The main piece that they're missing are branching operations. A unit recording device cannot change the flow of the program it's running. This may seem like a small distinction, but the idea of being able to perform a conditional branch is really at the core of what defines a true computer. Finally, we've arrived at the computing era in our story. Take a breath, because from here, we start seeing some of the strangeness that occurs when you combine a pre-digital, pre-computing format with new electrical and digital machines.

Very early electromechanical computers, such as Zeus's Z1 in 1938, read programs on punched paper tape, a close relative to the punched card. The history of early electromechanical devices is a very important and frankly insanely interesting story, but I'd like to save that for another day. Instead, let's talk about how new computers started changing punched cards. As computers started hitting the scientific and business scene in the 1950s or so, so too did new uses for the humble punched card. Computers of the time were able to use multiple types of storage. Large magnetic tape drives were often used for longer term storage of data and programs, and random access memory was now able to be used to hold short-term data and currently executing code.

But these systems still lacked much in the way of interactivity. That is to say, there wasn't a command line interface at all. Most of these early computers definitely didn't have a text editor, and it would be decades before there's any idea of a graphical interface. Instead, the punch cards stepped up as a means of interfacing with many of these early systems. Just as with the more antiquated unit recording equipment, a punch card station was used to encode data onto punch cards. However, there was often more than simple counting data going onto these cards. However, there was often more than simple accounting data going onto these cards.

Fully-fledged programs were now often written directly onto punch cards, loaded into the computer, and then executed. Gone were the days of single-purpose tabulators and barely flexible plug boards. Now a single computer could do all the tasks handled by earlier machines and much, much more. But there were still problems to be solved. Chiefly among those was that there was still no such thing as a programming language. Now, in the beginning, computers would have to be programmed directly by entering machine code instructions straight into memory. This was slow and difficult, to say the least, and often very error-prone. This is where programming languages start to appear and come to the rescue.

The main purpose of a programming language in this era was to make it so a human could write out what they want a computer to do in something closer to English or their native language, and then use a piece of code called a compiler to translate that program into something the computer could understand. The advantage of this was that it made programming easier, faster, and less error-prone. One of the first of these new programming languages was IBM's Formula Translation, more commonly and derisively known as Fortran. Love it or hate it, since 1956, Fortran has been in service all too regularly.

For those of you who haven't had the chance to experience the power and mystique of Fortran firsthand, let me explain a few things about the language. Primarily, Fortran was designed to be used for scientific applications, specifically the math-related parts of the sciences. However, the language was designed so early on in computing history that to any modern programmer, it seems bizarre and archaic. One of these oddities is that by default, most Fortran compilers enforce an 80 character limit on each line of code. Even more infuriating, the first few characters of each line are reserved for control characters. The reason for this strangeness? Let's think back,

where was the last time we heard the number 80? Oh yeah, of course, it's the punch card. Originally, Fortran could only be written on punched cards. Due to this, the language was designed to follow the restrictions of the 80-column IBM card. For the time, that was a great approach. You couldn't really write Fortran on anything else. It's not like you could write a nice letter to the computer in Fortran. However, these limits have stuck around as the default when programming in Fortran. Since Fortran is still widely used in a very similar form to its original incarnation, the 80-column limit shows up in some places you would never expect. For instance, NASA's Pleiades

cluster, one of the most powerful supercomputers in the world, runs a whole lot of Fortran. One of the major projects to come out of Pleiades was a simulation of the evolution of the dark matter in the universe. It's a massive program that has huge implications for astrophysics. That program, though, was written entirely in Fortran. Interestingly enough, we also see the 80-column limit in a lot of other computers in general. Most early terminals and text computer displays adopted the 80-column form factor since they were initially designed to replicate punch cards on glass. Due to this, the 80-column limit has sort of been added to the DNA of computing.

PCs default to an 80-column text mode on boot. If you're familiar at all with Linux, then you probably know that default terminals in that operating system are 80 columns wide, or that the source code style guide for the Linux kernel enforces an 80-character line limit. Another less technical area that punch cards have reared their head in are elections. Early plans for punch card-based voting, in the states at least, started circulating around the same time as the 1890 census. The high water point for this voting system was in the late 60s, early 70s,

with some 37% or so of ballots being cast using punched cards in the 1969 election. The company that made punched card ballots in the machinery to use them was called Votomatic. Voters would use a Votomatic device by sliding in their ballot and then using a stylus to manually punch holes in the card corresponding to their vote selection. Cards were then usually tabulated at the voting location. While overall this is a pretty reasonable way of casting and counting votes, the Votomatic ran into some issues that came to the front in

its latter years. The main problem was user error. The stylus has to be used correctly to make a clean punch, and it's not simple and it's definitely not something that people are exposed to anymore nowadays. If the punch isn't clear, it would often be counted incorrectly or not counted at all. One of the most publicized results of this was the 2000 U.S. presidential election. During this election, many Florida precincts used votamatics, and a good number of the ballots were poorly punched. Due to this, some ballots were incorrectly counted, leading to a contested result in Florida. These ballots had what were called hanging chads. That is to say that some of the rectangle punched out of the card was still attached to the card itself.

The Florida ballot has since been changed, but Votomatic and the punch card only stopped being used altogether very recently, But Votomatic and the punch card only stopped being used altogether very recently, with the last ballots being cast from a few counties in Idaho during the 2014 U.S. election. This episode's kind of turned into a grab bag of punch card history. I'm hoping, though, that I've addressed my original point. The humble punch card has a remarkable amount of influence in the current day, even if it may only be seldom seen in person. Thanks for listening to Advent of Computing.

We should be back in the next two weeks or so. Just as a hint, we'll be going all the way back to the 1960s to talk about the internet's early beginnings. If you like the show, you can visit our website adventofcomputing.libsyn.com. Also, if you enjoyed the programming, feel free to find us on iTunes and leave a review or share us with your friends.