From Punch Cards to Interactive Sessions: A Programmer’s Tale – Part 1

In the world of modern software development, with its sleek IDEs, instant feedback, and powerful debugging tools, it’s easy to forget how far we’ve come. As I sit here, surrounded by the fruits of decades of technological progress, my mind often wanders back to the early days of my programming career. It was a time of punch cards, paper tape, batch processing, and mainframes that filled entire rooms – a far cry from the pocket-sized supercomputers we carry around today.

For those of you who came of age in the era of personal computers and the internet, the landscape I’m about to describe might seem almost alien. Yet, it was in this environment that many of us oldies cut our teeth as programmers, developing skills and mindsets that would serve us well throughout our careers.

Join me on a journey back to the 1970s, where we’ll explore the day-to-day realities of programming in an age when computer time was a precious commodity and patience was not just a virtue, but a professional necessity. From the meticulous world of COBOL and punch cards to my clandestine adventures with BASIC on an ICL mainframe, and then a Commodore Pet and other microcomputers, this is a tale of perseverance, innovation, and the sheer joy of making these early electronic brains bend to our will.

So, grab a cup of tea, settle in, and let’s take a stroll down memory lane – a lane paved with punch cards, printer paper, and the unmistakable hum of mainframe computers and mahoosive air condition units.(also, Halon fire suppresion systems).

The Punch Card Era: COBOL and Batch Processing

The Rhythm of Batch Submissions

My programming odyssey began in the world of punch cards and COBOL. Each program was a stack of cards, meticulously punched and carefully handled. A single dropped deck could mean hours of re-sorting.

The Long Wait: Three to Four Day Turnaround

Patience wasn’t just a virtue; it was a requirement. After submitting our COBOL programs, we’d wait three to four days for results. This glacial pace meant each edit cycle was crucial. A single misplaced comma could cost you the better part of a week.

Debugging: A Test of Memory and Foresight

With such long turnaround times, debugging was an exercise in foresight. We couldn’t rely on quick iterations. Instead, we had to anticipate potential issues and include extensive error checking and output statements in every submission.

The Art of Desk Checking

To avoid wasting precious submission cycles, we became experts at desk checking – meticulously going through our code line by line, playing computer in our heads. It was tedious but necessary given the high cost of machine time and slow turnaround.

Sneaking into QMC: Learning BASIC on the ICL Mainframe

A Taste of Interactive Computing

My introduction to BASIC came when I started sneaking into Queen Mary College to use their ICL mainframe. It was a revelation – interactive computing that responded in seconds rather than days.

The Joy of Immediate Feedback

After the long waits of batch COBOL, BASIC felt miraculous. Type a line, run it, and see the results immediately. This rapid feedback loop transformed how I thought about programming and problem-solving.

Exploring in Real-Time

BASIC on the ICL mainframe opened up new possibilities for experimentation. I could try out ideas on the fly, tweaking and adjusting my code in real-time. It was like moving from writing letters to having a conversation.

The Thrill of Unauthorized Access

There was an added excitement to these BASIC sessions – the thrill of unofficial access. Each visit to QMC felt like a covert operation, driven by an insatiable curiosity to learn and experiment with this more responsive form of computing.

Reflections on the Transition

From Methodical Planning to Rapid Iteration

The shift from batch COBOL to interactive BASIC wasn’t just a change in languages; it was a fundamental shift in approach. COBOL required meticulous planning and foresight, while BASIC allowed for a more iterative, experimental style of coding.

The Evolution of Problem-Solving

This transition changed how I approached problems. With COBOL, every problem needed to be thoroughly understood and mapped out before coding began. BASIC allowed for a far more exploratory approach, where solutions could evolve through trial and error – what my late friend P Grant Rule used to call a “random walk”.

Appreciating Both Worlds

While the immediacy of BASIC was intoxicating, the discipline learned from COBOL batch processing was invaluable. It taught me the importance of careful planning and the value of writing clean, well-documented code from the start.

Other Early Languages

The ICL mainframe also provided SNOBOL, ALGOL 60 and 68, FORTRAN and others. So of course I had to dabble in those, too.

The Lasting Impact

This early experience with both batch and interactive programming laid a foundation that would serve me well in the years to come. It fostered an appreciation for both careful, structured approaches and rapid, iterative development – skills that remain relevant across all programming paradigms.

The contrast between the regimented world of punch cards and COBOL and the more dynamic environment of BASIC on the ICL mainframe encapsulates a pivotal moment in computing history. It was a time of transition from computing as a scarce, carefully rationed resource to a more accessible, interactive tool.

For those who’ve only known the immediate feedback of modern development environments, it might be hard to imagine the patience and precision required in those early days. Yet, these experiences shaped a generation of programmers, instilling a deep understanding of both the constraints and the potential of computing systems.

As we’ve progressed through various languages and paradigms since then, from assembler to high-level languages, from procedural to object-oriented programming, these early experiences continue to inform our approach to problem-solving and system design.

Next Up

If you’ve found this post interesting let me know and I’ll be happy to continue into PDP-11 Macro Assembler on a variety of PDP11s under RT11, RSTS-E and RSX, Wang Basic, VAX VMS Assembler, Pascal, Modula-2, Transputers, Forth, Smalltalk-80, and other languages of yesteryear. I’m keen to reminisce about the daily work of programmers back then, too.