Programming Experiences

From Cardpunches to Windows to the Internet

What follows is essentially an unfinished core dump of my experiences with computer programming. One of these days I will finish it. It's pretty dry reading, so be prepared.


The art of computing has changed dramatically in the last 20 years, in everything from the computers themselves, to languages and tools, to operating systems, to user-interface devices, to networks, and most importantly, to the ways in which all these things combine to enrich our interaction with the computer, and add to the ever-growing list of what they're able to do for us.

Ever since electronic computing began in the 1940s, computers have been exponentially growing in both speed and storage capacity, and reducing in size and power consumption, while the cost per unit of computing capacity has been steadily dropping. It's been said that if cars had developed in the same manner that computers have, a Rolls-Royce would now cost 50 cents and get a million miles per gallon of gasoline. There's more than just a kernel of truth in that saying.

Even just in my relatively short 15-year career, things have changed almost beyond recognition. The type of systems that kindergartners today take for granted, would have seemed to me like science fiction back when I first started programming in the '70s. But then, the things I took for granted back then would probably have seemed like science fiction to the programming old-timers of the '40s, '50s, and '60s.

So I thought I would try to describe to you my own (unfinished) journey through the world of computers and programming. It's a world that changes almost daily, and never ceases to amaze and excite me. Maybe there'll be an insight or two along the way that you'll find useful. (And maybe not :)

Please feel free to e-mail me some of your computing or programming experiences. I'd love to hear about them.

High School

I started programming in high school in the mid-70's, just before the personal computer revolution took place. In my first computer course, called "Computer Math," the computer we used was an old GE Mark IV mainframe that ran the GCOS operating system. We would punch our BASIC programs onto paper tape using a Bell ASR-33 teletype. Then we would upload our program from tape and test it. If it worked, we would just save the hardcopy of the run and turn it in. If not, we would log off, then punch our corrections onto a separate "patch" paper tape, log on again, re-upload, and re-test. We were discouraged from making programming changes "online" because the school was being charged by the minute, so access time was at a premium. We also couldn't store our programs on the computer's disk because there was an additional charge for disk space ("per K per day"). Thus we kept our paper-tape rolls on a pegboard on the wall, one peg to a student. That was our "mass-storage unit".


In 1977, I began college at Lamar University in Beaumont, Texas, seeking a degree in Computer Science. For the first two years there, technology-wise, things changed but superficially from high school. (By the way, the computer facilities have improved at Lamar quite a lot since then. Their facilities then were not abnormal for 1977.)

Instead of the teletype, we punched our FORTRAN programs offline onto IBM punched cards, then submitted our "job decks" for execution through a little window at the computer room. The results (a hardcopy of the job execution), along with the original job deck, would be placed in whatever output box you requested. We'd study the results, punch corrections onto new cards, insert them in the right places in the deck, and re-submit it. Sound familiar?

If we were lucky, we might get the results back in a couple of hours. If not, then the next day or maybe the day after. The "turnaround time" (the elapsed time between submitting the job and getting the results back) was a critical factor in whether or not you were able to get assignments done on time, and we were always complaining about it. Hard to believe that we could develop compilers this way, but we did. Back then, it was a matter of pride to get your program working with the fewest possible number of such turnarounds..

The worst possible thing was to drop your deck down a staircase, with the cards splattering in a million directions. One card equated to one line of code, so you can imagine how large some of these decks were. After much time and patience (and hopefully a recent program printout to act as a guide) you could reassemble the cards back into the proper order, but who would relish such a task? Luckily, this happened to me only once.

The computer was a Honeywell 6000 mainframe (the precursor of their current DPS-6 and DPS-8 lines).  Honeywell had just bought out whose line of mainframes?... you guessed it, GE. The 6000 ran... you guessed it, GCOS. I think MULTICS (of which the name "Unix" is a take-off) was also available for the Honeywell, but we didn't use that. (I also think you can still get a DPS computer with GCOS, but who would want one?)

In my junior year I was allowed to start using the "timesharing" terminals that were directly connected to the Honeywell. Using these, we could logon to the computer, and enter, test, and correct our programs "online". These dumb terminals (ADM-3A's, I think) could list your program and its output at the fantastic rate of 110 bps (compared to the modern dial-up modem which runs at 33,600 bps). To me, this was a miracle.

By now, I had learned BASIC, FORTRAN, Pascal, ALGOL, SNOBOL, Lisp, APL, COBOL, RPG, and GMAP, the Honeywell's assembly language. I had never even heard of "C".

Then, another new world opened up to me... after schmoozing with the faculty, I was allowed to start using the terminal in the Computer Science office, which connected to the Honeywell through an acoustic-coupler dial-up modem, which ran at the even more fantastic speed of 300 bps. I was in heaven.

Then came a radical new thing (for me) in 1978... A neighbor of mine who was a ham radio operator showed me a copy of Kilobaud Microcomputing magazine, which was an offshoot of the hams' "73" magazine. I had never heard of microcomputers before. In it there were ads for commercially available microcomputers, and BASIC programs you could run on them. This was a radically new concept for me: that there were computers that an individual could actually afford to buy, that used regular 110-volt, single-phase house current and required no special environment. Before, computers were (to me) gigantic, magical, mystical things that had to be locked away in computer rooms, serviced by High Priests, and protected from the Great Unwashed. And their cost was counted in the millions of dollars. Even the lowliest peripherals like dumb terminals could cost several thousand.

Among the microcomputers of the time, there were the Apple ][, the Radio Shack TRS-80 Model I, the Commodore PET, Ohio Scientific, the Altair, and a growing list of others. I had been working full-time at night through most of college and had some money put away, so being anxious to get one, I got the one that was easiest and fastest for me to obtain. I went to the local Radio Shack store and got a TRS-80 Model I Level II (they only had to send to Houston for one) for $850.

Diskettes, modems, and printers were not yet available for it (nor was the expansion interface which you would need for such things.) Its only storage device was a cassette drive. It came with 16K of RAM, and a 16K BASIC interpreter permanently fixed in ROM, written by none other then Microsoft's Bill Gates.

That little computer opened up vast new worlds for me. I could write programs for it, alter and experiment with them any way I wanted, run them however many times I wanted, because it was mine. Why, I could even WASTE its time, if I wanted. I could put my hands on it, and take it apart and put it back together if I wanted. These were things I could never do to that big-iron Honeywell.

Many were the all-night programming sessions. I learned the assembly language of its CPU chip, the Z80, and I spent many happy hours disassembling the BASIC interpreter in ROM, and mapping out the utility subroutines it contained so I could call them from my own assembly-language programs. I subscribed to Kilobaud and Byte magazines, and adapted programs listed in them.

[to be continued...]

[Return to Top] [Return to Home Page]

Copyright 1997, Darrell Pittman. All Rights Reserved.