How Developers Programmed in the 70’s

March 14, 2019 Posted by Programming 0 thoughts on “How Developers Programmed in the 70’s”


On Tuesday, we celebrated the 30th anniversary of the internet. Today, we’ll go back in time to the 70’s to explore how developers produced code for computers in a time where the intranet wasn’t a thing, let alone the internet.

The 70’s Computer

“Small” digital computers at the time still required large processors, which accounted for the amount of space these early computers took up. These massive computers were often framed and thus earned the name mainframes. Mainframes were used in a variety of large scale operation like industrial factories and other industries that required large data processing. Though mainframes today aren’t as large as they once were, these computers are still large relative to the average workstation, taking up the space of a refrigerator.


These processors had several parts that worked in conjunction to one another.  These parts included the main store, arithmetic unit, control unit and registers. You also had input and output centers. Today we’re used to having our input and output seamlessly integrated. But, in the 1970s, cards would be fed into the card reader, fed into memory, processed, and displayed onto the screen.


Programming in the 70’s

Developers at the time had to develop programs on punch cards due to the input system we mentioned earlier. Coding at the time was quite literally code-writing because a number of holes corresponding to a character would be punched into a card. Due to the slow nature of this process, coders would punch out code on a separate machine till they had a suitable amount of cards to feed into the computer. Like Assembly Language and Machine Language, each computer would have its own punch card design.



It can be hard to imagine life as a programmer back in the 70’s, so let’s look at some excerpts from Dale Fisk’s memoir called “Programming with Punch Cards.” At the time, he was an engineer tasked with learning how to program on punch cards for the first time.

“Writing a program began with a paper tablet of coding forms. Each page of the tablet had
about fifty lines on it, and each line on the form would eventually be converted into a
punched card and stowed away in a box with a bunch of other cards.”

Once the cards were ready to be used by a programmer, the cards would be placed into a keypunch printer to translate the illegible code into text that humans can understand.  This allowed programmers to more easily debug their own code. Tracing bugs was more of a nightmare than it is today due to the long feedback loop. You only have to read this passage to get an idea:

The first thing I did was to admire the first page of the computer printout where my name
was blazed across it in three-inch letters. No need for reading glasses here! Lifting the
first page of the stack of fanfold paper, I studied the first of several pages telling me in
great detail how the computer had first understood what program I wanted to run — the
compiler — and what to do with the result — print out a report and create a punched card
deck containing the program.

Then it dawned on me. The computer had not created that program deck that I told the
compiler program to produce! Dumb computers! I had this small stack of paper but no
punched cards. Clearly the computer had messed up somehow. I’d have to fix that.”


Then Fisk does what anyone new to programming would do:

I turned a couple more pages of the computer printout and finally found the section where
the compiler started to process the source deck. And, the compiler immediately did the
equivalent of a computer barf!

An error message described in infinite detail some problem. The computer obviously had hiccuped and done the wrong thing! The only
thing to do was to rerun the program – the compiler – and give the computer a chance to
do it right this time.

I took my source deck back to the computer lab and called the computer operator over,
telling him that his computer had messed up and that I wanted him to redo the request I
had originally put in. He said: “Are you sure?” I was. “Just as soon as the program
running now finishes,” he said. He took a stack of punched cards out of the card reader,
set them aside and put mine in their place.

I impatiently waited for the present program to finish so the computer would redo my source deck. I remember wondering a trifle
guiltily whose cards the operator took out of the card reader in order to redo my request.
It didn’t take long before the other program finished and mine started.

Then, almost immediately, I got another stack of paper back. Again no program deck! In fact, the oneeighth inch stack of computer printout showed the exact same error message I had seen earlier.”

Finally, Fisk realized that he was missing a comma when he looked more closely at his punch cards. He’d debugged his code for the first time. His ordeal gives you a glimpse into what programming on the IBM 360 was like back in the 70’s, a time where computers were not fully digitized. His piece is worth a read for anyone looking to see how someone from the 70’s regarded the complex machinery they called a computer. Just as a side note, programmers fed code into computers through other means, like the use of magnetic tape, which was more durable than paper punch cards.




Please follow and like us: