In some ways, I feel that I personally have experienced firsthand the full evolution of modern computing technology. Let’s start at the beginning…
Microcomputer: Pre-PC
As a teen, my oldest brother had a tabletop RadioShack microcomputer called a TRS-80. You could almost consider it an early PC (personal computer), though the term ‘PC’ hadn’t become common yet. It had floppy drives, a keyboard, and a text-only display. You could do basic programming on it (lowercase ‘basic’, not the BASIC programming language) to manipulate numbers, etc. I spent some time with it, though it really didn’t interest me that much.
A few years later, as an undergrad at a big engineering school, we used low-end microcomputers similar to the TRS-80 to program in assembly language. (Assembly language, if you don’t know, is a simple set of foundational commands upon which higher-level programming languages are built.) The real advantage of microcomputers is that they were individual — they sat on a desk or table, and were intended to be used exclusively by one person at a time (= ‘personal’ computer). This usage model was revolutionary, because computers to date were large beasts that were shared — like a refrigerator or stove. You’d walk up to it, use it briefly (to run a program), then leave it for the next person to use. These larger shared computers were called ‘minicomputers’ — because they were smaller than mainframes.
Minicomputers: Bigger Shared Beasts
Minicomputers were the size of a desk, or an upright piano. You would feed it a stack of cards that contained your program, it would read and execute, and give you the result. It didn’t store your program — each time you wanted to run your program, you had to re-feed it that stack of cards. We had a minicomputer at my high school, and also in college. These minicomputers handled more-advanced programming languages.
There were several hilarious things about the cards that contained your program for a minicomputer:
-
- Order – First, the cards were either punched or were filled out with pencil, with each card representing a line of code. You had to deliver the cards to the minicomputer in the right order, or the lines in your program wouldn’t be in the right order. I can remember in college seeing fellow students carrying a stack of 100+ cards, and accidentally dropping them — forcing them to collect all the dropped cards, and go through the painful process of restoring them to the proper order.
- Pencil – The other hilarious thing about the cards was: when they were the type where you ‘coded’ them by filling out the dots in pencil (called ‘mark sense’ cards), the pencil marks would wear away after a few reads by the minicomputer, so it would no longer correctly read your program. You then had to go through your card stack with a pencil and darken all the dots to get them back to readable.
Mainframes at a Defense Contractor
Two Steps Forward, One Step Back
Out of engineering school, I hired into a defense contractor. (This was in the 1980s when Republicans were in office and defense spending was strong.) It was a rewarding, well-paying job (but with the overhanging shadow of doubt that you were contributing to technology that helped war — which resulted in the deaths of fellow humans). I was there for four years, then left for greener pastures.
One of the projects I was on (which never launched) involved estimating the time to develop a missile launcher that would ride on an armored personnel carrier (which is sort of an entry-level tank). The estimation exercise was funny because we were purposefully given false numbers about the capability of the missile launcher — because the true numbers were classified, and we didn’t have sufficient security clearance. The false numbers (unsurprisingly) skewed our work estimates — which turned out to be too high for the project to get a green light. 😒 But back to computing…
There are two factors that made it interesting to work at a defense contractor in the 1980s: (1) the technology was behind current industry standards, and (2) the available spend rate was generous. This meant that you were working with older technology — in part, because it was a lengthy process to get new technology approved/certified for use — but, you had the ability to throw money and resources at a problem to address it. Four ‘low-end computing’ examples come to mind:
-
- Microprocessors – First, one of my initial assignments was introducing microprocessors to the electronics within the armored personnel carriers (which, again, were like entry-level tanks). So we were chopping out analog circuitry — which I studied in school (‘analog circuitry’ means the logic is executed by a network of simple electronic ‘switches’) and replacing it with microprocessors running software. In our situation, since we were a defense contractor, we needed to use an approved programming language — Ada. (So I took an external class at a local junior college to learn the Ada programming language.) Overall, the project in a nutshell was: remove analog circuitry, drop in a microprocessor running software, and ensure that everything worked the same as it used to work. Kind of crazy, but in concept it set things up for easier future innovation.
- Mainframe Storage – My second example of dealing with old/outdated technology was around the types of computers that we had to use. For serious computing tasks, we used what were essentially ‘mainframes’, because they were large animals that took up most of a wall with a room. (Individual employees did have PCs which got fancier over time.) These mainframes were programmed in a relatively modern way (though there were stories about people in earlier times who had to flip switches on the face of the computer to program it). The one thing that stands out in dealing with these large computers is the storage device. The removable media that was used to deliver programs wasn’t a CD or a floppy disk, rather it was a large disk drive which was the size of a round garbage can lid — it had a handle in the middle of the top that made it easy for you to lift it out of the device that read it. So if you wanted to change or deliver information/programs to the computer, you would open up this large mini-fridge sized device, take out the large storage media that was there (by grabbing its handle and lifting it out) and then drop the new media in — which again, was a large round flat disc with a handle in the middle of the top.
- ‘Portable’ Computers – My third example of dealing with old technology was around portable computing. It’s easy today to under-appreciate the sophistication in computing power within portable devices like cell phones. Even laptops with high-quality screens and low-profile keyboards — that are packaged in a way that are easily transportable — are quite innovative. Back at the beginning (decades ago), there wasn’t an easy way to carry around a computing device from place to place. The task to make computing portable at that time essentially was: to take a personal computer and package it in a way that allowed someone to lug it around — which essentially meant: make it flat, and put it into a case that was sort of like the suitcase. We contracted with a third-party to help us test our electronics. They provided a device that we could connect to the electronics that we were developing, and that device would exercise those electronics, and determine how these electronics behaved at the extreme ends of their intended ranges — so you would know whether you need to adjust the electronics to better withstand some real world variability. They brought this test device to our office, and it was this device — a ‘portable’ PC — that was a prime example of portable computing at that time. The device they brought was essentially a plastic suitcase containing a flattened PC with a tiny built-in display — with plugs that you connect to your electronics and test to see how it performed. It was not a light device that they brought — my guess is maybe 30-40 pounds. The guy who carried it around was a pretty big guy. It’s possible that a smaller person might have had much more of a challenge lugging this device from client to client.
- Distributed Processing – My fourth and final example of encountering, and making the most of, outdated computing was around ‘distributed computing’. Today, with public ‘cloud’ computing, you can send a job off to a server farm owned by Amazon or Google or Microsoft and (realtime) access the computing power that you need to run your job. Way back when, there was no internet or server farms. (I used to be in charge of the ‘network’ at my work — which was really just ensuring everyone could use the printer.) I often had large computing jobs that could take days to run. However, I would instead stay late at work, divide my job up into smaller portions, and run each of those sub-jobs on the computers at other employees’ desks. So I would walk from desk to desk, load my program onto my coworkers’ computers, and run it. And I would do this maybe 20 times. I would then cycle through again, collect the results, and assemble them into a overall whole. Unfortunately for my wife, this kept me late at work some days, but it did allow me to accomplish more than I could have otherwise. What’s interesting about this exercise, is that I had easy access to each of my coworkers’ computers. That is, there were no passwords preventing me from using their computers. Today, though this exercise wouldn’t be necessary, common security practices wouldn’t allow one employee to easily access another employee’s computer.
Moving On
Anyway, wrapping things up, I subsequently moved from the defense contractor to an airline, then a telecom company and, each time, gained some ground in available computing devices — but nothing as drastic as those first four years at a defense contractor in the 1980s.
