Edit – Compile – Run V1

My first experience with computers and programming at UT was on the CDC (Control Data Corp) Dual Cyber System mainframe in 1981. The class was PEN 310 (I started out as a Petroleum Engineering major). Programs were written in Fortran using punch cards. You had your deck of blank cards, you’d insert them into this punch card machine (there was a big room full of ’em in Taylor Hall). And you’d type one statement at a time and the machine would punch the statement onto a card for you. The punch card machine was this big desk sized device at which you stationed yourself and did your card punching. You lay your stack of blank cards in one slot and they’d be fed through the machinery, punched and stacked for you in another slot.

punch cards

BTW, as I recall there was no backspace key. IOW as you type each key it punched the card at that moment. So if you made a mistake before finishing one line of code, you’d eject the card and start over. You had to love it.

Then after you got your program keyed onto cards you took your card deck (being especially careful not to drop it) across the hall to the batch operator/center. I don’t remember exactly what the name for this location was but it was basically a remote terminal or port for the mainframe, and there were a number of them around campus. There was this long counter behind which the operator would be working. You’d hand him your deck of cards and he’d feed them into the card reader. The card reader was a counter top device that read the cards and sent the data across campus to the mainframe. Then behind the counter were a number of printers. These printers had a footprint about that of a small desk and stood a little taller. These printers were continuously spewing out continuous wide form feed paper.

The CDC mainframe was located in the old Computation Center. This was located in the shadow of the Tower sort of below ground just east of the Tower. You can still see the doors to this place but it’s now closed to the public AFAICT (While giving a campus tour to some friends once I tried to lead us in and we were quickly confronted by security people). However back then it was open and you could walk down the length of this long hall. All along the west side of the hall was a window into the Computation Center and there in all it’s glory behind glass was the mainframe. The large room was full of big components of tape readers, disk storage and two very large CRT consoles. It was an awe inspiring site for a sophomore just discovering computers.

Every job submitted via cards was loaded onto the mainframe, executed, and the program and execution results were printed out on paper. (No CRTs allowed for lowly PEN 310 students, not yet anyway). So these printers were constantly going and the operators stayed busy between loading the card reader and grabbing the printouts and placing them out on the big counter for the owner to retrieve. Each printed “job” began with a header page which was your ID in big banner print so as to be easy to read at a distance. So the operator’s job was to gather up the printouts, tear and fold them correctly so the header was facing up, then lay them out on the counter visibly. There was always a huddle of people standing by the counter waiting for their job printout to appear on the counter.

Once you retrieved you printout you then head over to one of the large tables in the punch card room so you could spread out the printout and begin debugging your program. Debugging mostly consisted of mentally executing the code in your head while reading over the program printout, and of course you’re aided by the results of the last run printed at the end of the printout, and perhaps sketching out a table of variables/values on the side.

Once you determine your code changes you then go and get on a punch card machine (hopefully not having to wait long to get on one) and punch out a few new cards to either insert into your deck or replace existing cards with. Each card was one statement so of course the card ordering was critical.

This was my first experience with the edit-compile-run cycle.