When Programming Meant Punch Cards and Patience
One step up from a Teletype and BASIC
An IBM 029 Card Punch. Image from TwoBitHistory.org.
In an earlier LifeBits post (Basically Speaking), I wrote about my first brush with computing—typing BASIC programs into a Teletype and watching results clatter out seconds later. Saving your work meant punching it onto paper tape, looping it, and securing it with a rubber band. Primitive? Absolutely. But it worked.
Then I arrived at the University of Colorado Boulder in the fall of 1974 and met what felt like real computing.
CS101 introduced budding engineers like me to Fortran—specifically Fortran IV, the lingua franca of engineering at the time. Developed by IBM in the 1950s under computer scientist John Backus, Fortran (the “Formula Translating System”) debuted in 1957—just months before I did. Backus famously said he created it out of laziness:
“I didn’t like writing programs… so I started work on a programming system to make it easier.” (Source: NBC News article about John Backus’ death)
A man after my own heart!
Thanks to BASIC, I took to Fortran quickly. The chart below shows that the BASIC language was actually an offshoot from Fortran II, something I didn’t know until I started writing this post!
A timeline and family tree of the Algol, Fortran, and COBOL programming language families. Skippppp, Shazz, Borkowsk, Qwertyus, MáneyMánadóttir, CC BY-SA 4.0, via Wikimedia Commons
What really grabbed me was the FORMAT statement—an incredibly flexible way to shape output. I won’t go into boring detail about how this statement worked along with the READ and WRITE statements, but will direct you to this link if you’re interested.
In my first job as a real-life engineer, I pushed it to the limit, modifying a gas distribution network analysis program to “draw” crude character-based maps of the Denver natural gas distribution system using text output. Not exactly modern graphics, but at the time (1979-81), it felt revolutionary.
The real pain wasn’t the programming language we were using as students. It was the interface we were using to converse with the computer. To run a program, you didn’t just type and hit return. You stood in line for an IBM 029 card punch, the machine you see in the image at the top of this article. Each line of code went onto a separate card. Type carefully—because there was no backspace. One mistake? Toss the card and start over.
Image of a Fortran statement punch card. Source unknown.
A full program meant a deck of cards, plus special header and trailer cards to tell the system where your job began and ended, and another card with your name and class code (so the university could bill the right account). Once your deck was ready, you’d wrap it in a rubber band and drop it into the input bin.
Then you waited.
CS101 students shared the mainframe with everyone—grad students, researchers, payroll, the class scheduling system, and other people running massive jobs. Sometimes your tiny assignment would sit for hours behind a monster run. Eventually, your output would appear in the out box, printed on green-bar paper.
The dreaded continuous feed green bar paper used with line printers for mainframe output. Image source unknown.
That moment of picking up your printout was pure suspense. Did it work? Or were you headed back to the card punch line?
Those early CS101 assignments were small (mercifully), but things escalated in my junior and senior years. In a structural analysis class, we modeled large space frames—complex 3D truss structures used in buildings. The core program was loaded via header cards; our job was to define everything else: materials, beam types, connections, coordinates. For large models, that meant hundreds or thousands of cards.
Heaven help you if you dropped your deck. Card order mattered. Lose it, and your program was garbage. The solution? Draw a diagonal line across the entire deck with a marker (as seen in the image below) so you could reassemble it if disaster struck. Low-tech, but highly effective.
ArnoldReinhold, PunchCardDecks.agr, CC BY-SA 2.5
After college, I kept using Fortran—thankfully without the cards. By then I had access to an IBM 3279 terminal at work. Jobs were still batched, though, and since our office didn’t have a line printer, we’d wait a day or two for output to arrive via company mail. But now I was getting paid, so the wait didn’t sting as much.
If you’re one of the few who remember punch cards and Fortran, I’d love to hear your stories—whether they were fun, frustrating, or somewhere in between.
I hope you enjoyed this time traveling trip back to what computing was like 50+ years ago. If you could “Like” this post it would make me deliriously happy, and if you’re not a subscriber, sign up for FREE to receive these occasional posts in your email inbox. Sharing LifeBits with your friends is another way you can help!