Job Control Language
Cleaning out my cupboards last week, I came across something unexpected. Software documentation that apparently I wrote in 1981. I have no recollection of it, nor do I know why I wrote it. All I recognized was the name of the co-author, Linda, a classmate of mine during that, the last of my seven years at the University of British Columbia.
The document is historical not only for it being the first software documentation I ever wrote, but also in how it was produced.
My first direct experience with computers was UBC's mainframe, an Amdahl that was plug-compatible with the then-standard IBM/360. In a huge linoleum-floored, fluorescent-lit, noisy cardpunch machine-filled room, we undergrads wrote our brief programs into punchcards, one line of code per card. A deck represented the entire program. We ran the deck through a card reader, and then waited on the result. With dozens (hundreds?) of undergrads running programs on that single shared computer, the wait tended to be longish.
The results of our programs came from an enormous line printer that commanded the center of the room. It was called a "line printer," because it printed an entire line of text at a time -- 132 characters at once on tractor-fed green-white stripped paper. It clattered noisily but was pretty fast. It commanded the room, because we gathered about it as we hoped our programs would not generate results that contained the words of dismay, *WARNING* or *ERROR*.
Whenever the printer encountered a problem, it slowly and magnificently raised its hood at us. Foolish undergrads who, while waiting for their printout, placed their card deck atop the printer saw the cards sailing through the air like a game of 52-pickup. The rest of us waiting for our results erupted in loud cheers at the sight.
There was no interactivity; this was batch computing at its coarsest level. Or, as we called it at the time, "jobs." Grads, however, accessed the mainframe through interactive terminals. I still recall the feeling of awe from the first time I entered the terminal room. It was bathed in very subdued lighting, had carpeting on the floor and individual cubicles housed green-screen terminals with padded office chairs. Hushed, with only the quiet clicking of keyboards. It felt like the engineering deck of an UFO.
Having access to a terminal also meant we could store files; no more card decks flying through the air! Although the first year or so, I had no concept of the difference between data files, programs, the operating system, eh?. I did love the commands I now could deploy: CREATE EARTH (create a file named 'earth'), then KILL EARTH (erase the file). The power!
At first the terminals were limited to line editors. To edit text with this kind of text editor, you would enter the number of a line, use control keys to move the cursor along the line, and then make the change. Pressing Enter committed the change to the file. (Early versions of MS-DOS were no different: the text editor Microsoft wrote was called EdLin, and it also edited text just one line at time.) Clumsy, frustrating, and only slightly better than using punch cards.
During my last year, the University of British Columbia Computing Department experimented with a full-screen editor. This was an amazing advance: now we could move the cursor anywhere on the screen to make an edit. For me, however, as a touch typist, this was a multi-million-dollar computer finally catching up to my $400 typewriter; the difference, of course, being that I no longer needed to retype pages.
So while programs were now stored as files instead of punchcards, the output was done in exactly the same way. We had to wait for a printer to spit out results. Less conveniently, the printer was in the basement of the computing center, while our lush terminal room was two stories up. At least we got the exercise of running up and down the stairs.
The printer was one of the first laser printers in the world. Made by Xerox, the 9700 was as long as an automobile. It offered one font, Courier, and printed at 300dpi. However, it was blazingly fast: two pages a second. As we waited for our output to be pigeon-holed by the computing center staff, we could hear it quietly making that tick-tick sound, twice a second, for each page being printed. When done printing a job, it added a cover sheet identifying the job as ours, and then stapled the pages together.
The computing center developed the full-screen editor further, adding features like bold (*B*) and italics (*I*) codes that we embedded into the text and different fonts. I never did figure out how to specify a different font; Courier was good enough.
And so we come to this piece of documentation, my first. I have no idea why Linda and I were tasked with writing it for the GVRD, the Greater Vancouver Regional District (now Metro Vancouver). At the time I was taking classes in the faculty of Community and Regional Planning, and my engineering specialization was transportation, so perhaps a prof had us do it as a class assignment.
No matter; I loved to write and the full screen editor was the breakthrough I'd been waiting for since I learned to touchtype a decade earlier in Typing 9. Editing without retyping!
The manual described the JCL (job control language) syntax for running a program that simulated land use and traffic flows. Running the program cost 37 cents a second. Running the program from a terminal added a surcharge of 40%. Data was stored on tapes that cost $1 to mount and then 30 cents a minute while mounted. Printouts of the result cost 3 cents a page of paper plus 4.8 cents for 120 lines (a page of text). A typical run cost about $20 (about $50 today, with inflation). Today's cloud computing regresses to those bad old days.
When two years later I got my first computer, a Victor 9000, it came with no software other than what MS-DOS v1.x included -- the EdLin line editor, with which I wrote. A brilliant friend who camped in my apartment for a couple of months while waiting for his job to begin wrote me a full-screen editor in MS-BASIC. (That was all I asked from him in terms of rent.) To make it fast, he wrote it as a single, large array that held all the text. This approach limited files to about ten pages, max, but that was all I needed to be productive. Thanks, Norbert! I added function key definitions that added formatting and so on.
The true brilliance of the personal computer was that it no longer cost each time I needed to run a program. Sure, the computer (and printer and cables and diskettes) came to $6,000 (about $15,000 in today's money), but after that it was free to use.
Little did I realized that four years after I left UBC I'd leave my position as a professional engineer -- forever -- to become a professional technical writer in September, 1985.
I was there to watch the progression from line editor to text editor to word processor to desktop publishing.