Remembrance of computers past

[This post was originally created in response to a question from a reader: “After reading your latest post, I’m curious: what was your early career like? Technology was very different back then.”]

First, thank you for the ask! This is the first one I’ve gotten. I am not by nature inclined toward nostalgia, computer-related or otherwise. (That’s why I spend my time on Cohost nowadays and not on Facebook.) But since you want to know, I will tell you how things were.

When people think about computing decades ago they normally contrast the hulking mainframes beloved of old movies, all spinning tape drives and flashing lights, with the “supercomputer in your pocket” that is the present-day smartphone. But many things have not changed as much as you might think, and in some cases I’d highlight changes in culture, especially including work culture, as much as I would changes in technology.

To expand on this in terms of my own career:

A corndog meets a computer

My first introduction to computers was when I visited the college I would later attend. Though a small school, they prided themselves on having modern facilities and equipment, one of which was a DEC PDP-8/E minicomputer. (I naïvely asked if it was an analog or digital computer; as D. Boon might say, I was a “fucking corndog.”) Once I was a student, I and others had fun learning BASIC, tediously pecking out programs on a Teletype machine to be recorded on paper tape and then read back and executed.

Later I assisted my physics professor with some programs he was creating. These were in FORTRAN, and to run them we had to drive half an hour to the nearest university computing center. There we spent our time typing out new punch cards for program changes, submitting them to the computing center help desk to be run on their IBM 370 mainframe, and then waiting for the output. We typically got in one run a day, and did this one day a week.

My last semester in college I spent at Oak Ridge National Laboratory, helping two researchers improve their computations of how electrons were absorbed by water (a problem relevant to radiation treatments for cancer). This was another FORTRAN batch job gig, but I was able to use a Wang 2200 system (see above) to do preliminary calculations in BASIC. (The full calculations were too much for the Wang.) This was my first experience with usable interactive computing.

My life as a software developer

After college I went to work as a software developer for a small (20 person or so) software company, SIMPLAN Systems, developing econometric modeling software. This was pretty interesting: the program featured an embedded interpreted language you could use to write and run econometric models on time series data. It included various statistical functions, and was in some ways similar to the later R language. The software itself (parser, runtime, etc.) was written in PL/I (not “PL/1,” thankyouverymuch), and I worked on adding new language features.

And here’s where the software development itself was not necessarily all that different from what is done today. The PL/I language was created by IBM as a successor to COBOL and FORTRAN, but never achieved their level of success. However as a language it was relatively advanced for its time, and except for the use of ALL CAPS (a holdover from the punch card era) a present-day C or Python developer would likely find the syntax of a PL/I program to be relatively familiar and its semantics readily understandable.

The actual development process may not have been all that alien to a modern developer either. When I started there, we didn’t have an actual computer in our office, but instead used Texas Instruments Silent 700 terminals to connect to a time-sharing system (IBM TSO, and later VM/CMS) at a university computing center some distance away. The Silent 700 combined a keyboard, a printer that used thermal paper, and a 300 baud acoustic coupler modem that you stuck your phone handset into.

This was a more congenial way to work than you might think. I can’t write code at a rate of more than 30 characters per second and I can’t read code much faster than that either, so the connection speed wasn’t much of a problem. The editor we used was similar to the “ed” line editor still found on Linux and macOS, and we used it in very much the same way: find where you wanted to change or add lines, print the code around it, make the change, print some more lines to check the change, save the file, compile and link it, and then run it with sample input to test the change. With VM/CMS we actually instantiated a virtual machine, attached our persistent storage to it, and ran the code in an isolated environment.

What strikes me as really different in retrospect is not the computing technology, but rather the environment in which we worked. When I started I got a real office (i.e., floor to ceiling walls) with a solid and pretty soundproof wooden door, an office I had all by myself for a while until a new developer came on board. We could work in our offices without distractions: no emails, no Slack notifications, no smartphone apps or websites to grab our attention, and (at least in our company) no endless rounds of staff meetings, code reviews, etc. And because the Silent 700s were portable, we could even take them home and work from there with even fewer distractions—not even phone calls could interrupt us, because the phone line would be tied up with the modem connection.

The real hassle came with software distribution. We sold the software to corporate economists (at about $50-100K US in present-day currency), and I was the main person tasked with installing it for them. I had to login and run a job to generate a copy of the software on magnetic tape, drive out to the university computing center to pick up the tape, and then drive to the nearby airport to fly out to the customer’s offices, there to give the tape to their computing center staff and work with them to get it installed.

Exit the mainframe, enter the supermini

Eventually SIMPLAN Systems got its own computer system, a “superminicomputer” from Prime Computer. Since the company didn’t have a lot of money we had a relatively low-end system, with only 512KB of memory and (I think) 80MB of disk storage. It also had an interactive operating system (PRIMOS) with a command line shell, and either then or a bit later a (non-GNU) version of the Emacs editor. That together with a Prime CRT terminal (similar to the famous DEC VT100, the ancestor of today’s terminal.app) was my introduction to full-screen editing.

After doing some work to help port the SIMPLAN software to the Prime system, I moved to Washington DC, left software development behind, and went to work for Prime Computer itself as a so-called “systems engineer” assisting with the sale of Prime systems to commercial and government customers. (I had enjoyed working with customers, got along well with salespeople, and was bored doing programming full-time.)

Prime and PRIMOS were also relatively advanced for the time. The operating system was written in PL/P, a dialect of PL/I, and since customers got source code for PRIMOS you could even make your own mods to the OS. Prime systems could also be connected to a (Prime-proprietary) local area network, and eventually we even got access to the Internet and acquired real email addresses to use with it, as well as FTP access to download software.

But even better than the Internet was getting access to actual text processing software. I’ve never been a fan of WYSIWG word processing software, so I was happy when Prime got us copies of the Scribe markup language software, and I later got a copy of the TeX mathematical typesetting software myself. These along with one of the recently-introduced laser printers enabled me to finally get away from using typewriters to create documents. (As an example of the crap output we were stuck with in the pre-TeX era, see the paper I wrote at Oak Ridge.)

As at SIMPLAN Systems, software distribution continued to be a pain in the ass. In addition to using magnetic tapes, we also resorted to carting around removable disk packs, which we pulled out of the actual drives (which resembled washing machines—see above), put in plastic containers, and then took on planes as carry-on items when we needed to visit the corporate HQ. Given that the disk platters were exposed to the open air while we were moving them around, I’m surprised we never had one crash on us.

My period at Prime also introduced me to Unix, as Prime created a new line of “super micro” systems based on the Intel 80386 microprocessor and running Unix System V. That’s when I made my entrance into the online historical record, since I ported GNU Emacs to the Prime EXL line and then posted about it to Usenet.

Or, to be more precise, I posted it to a mailing list that was gatewayed into a Usenet newsgroup. I didn’t have access to Usenet proper until a later job at which a co-worker of mine had set up a working connection to other Usenet nodes. He was an evangelical Christian, and I found it amusing (and never told him) that taking a full Usenet feed, including the alt.* newsgroups, meant that—in addition to innocuous stuff like the comp.sys.ibm and rec.arts.movies newsgroups—he was storing on company systems multiple megabytes of text-based erotica, along with even more megabytes of uuencoded erotic art and photos.

That brings me back to contrasting the differences in culture then and now vs. differences in technologies. The environment in which we worked was almost completely white, almost completely male, and pretty much completely cishet. Because we were expected to be “professional” and be ready to visit customers at any time, I had to wear a full suit and tie Every.Fucking.Day.

If I recall, we only had a few women in our sales office, one a salesperson and one a pre-sales technical person like me, plus a receptionist and secretary or two. The pre-sales technical person I suspected of being a closeted lesbian after I got invited to her going-away lunch (the only man to be invited, if I recall correctly) and met her very butch “friend”; she would never have dared to talk about this with her co-workers. Somewhat later I had a co-worker who was a trans woman, the first one I’d met, but this was a bit more understandable since she was a software developer and I was working at a small company again. (She’s still working in the tech field; I found her on LinkedIn when I did a search last night.)

This is all to say, that if those of you reading this on Cohost were transported back 30 years or so, I suspect you’d be far more shocked by the “backward” culture than you would be by the “backward” computing technologies.

Last days before the Web

During this general time (late 1980s, early 1990s) I also worked with a number of Unix-based workstations. I’ve written about this previously, so I’ll be brief and just say that I never want to see—let alone lift—a CRT-based workstation ever again.

This brings us to the mid-1990s, and I think an appropriate place to stop. Everything changed when the World Wide Web hit the scene, but in some senses a lot of things haven’t changed much since that time: I used Mac laptops then (Powerbook 140 and its successors), I use a Mac laptop now (MacBook Air). I used a web browser then (NCSA Mosaic and then Netscape Navigator), I use web browsers now (Safari, Firefox, and sometimes Chrome). I did occasional programming in an interpreted language then (Perl), I do occasional programming in an interpreted language now (Python). We had websites, blogs, and online forums then, we have websites, blogs, and online forums now.

There are in fact new things in computing in the 21st century: smartphones, cloud computing, maybe LLMs if they become more useful. But it’s also true that there were a lot of innovations in computing back in the day, innovations that in many cases got left by the wayside, never to be followed up or revisited. (Brett Victor hammers home this point in his presentation “The Future of Programming.”) They were interesting times to be in the computing field, and I hope this post has given you a bit of a taste for how things were.