Computers That Never Were

Today it is easier than ever to learn how to program a computer. Everyone has one (and probably has several) and there are tons of resources available. You can even program entirely in your web browser and avoid having to install programming languages and other arcane software. But it wasn’t always like this. In the sixties and seventies, you usually learned to program on computers that didn’t exist. I was recently musing about those computers that were never real and wondering if we are better off now with a computer at every neophyte’s fingertips or if somehow these fictional computing devices were useful in the education process.

Back in the day, almost no one had a computer. Even if you were in the computer business, the chances that you had a computer that was all yours was almost unheard of. In the old days, computers cost money — a lot of money. They required special power and cooling. They needed a platoon of people to operate them. They took up a lot of space. The idea of letting students just run programs to learn was ludicrous.

The Answer

If you look at computer books from that time period, they weren’t aimed at a particular computer that you could buy. That might be surprising at first glance since at the time there were not many different kinds of computers. Instead, the books focused on some made-up computer. There were two reasons for this. First, it ensured that as many people as possible could benefit from the book — the market was a lot smaller than it is today. Second, the made-up computer was usually set up to be easier to understand than the real computers of the day.

This last point is important because you were not going to be allowed to run your programs anyway. You’d test your ideas by pretending to be the computer and working out what was going on manually. Your instructor (or, more likely, a grad student) would do the same thing to determine if you got the right answer or not. Trying to simulate exact hardware of a specific CPU didn’t make much sense.

However, these systems all had one thing in common. They forced you to really understand what the computer was doing at a low level. You can’t write a single line of code to print the sum of two numbers. You have to code the operations to load the numbers, code the addition operation, and then understand where the result goes. You had to be the computer.

You could argue that some of that is just learning assembly language or, at least, a low-level language. However, you’ll see that because for most of these systems (at least in their time) you were the computer, you had to really understand the processor’s workflow.


My first exposure to this technique was from a book I got from a local library in the 1970s. It was an old book even then (from 1962). In fact, there were a few versions of the book with slightly different titles, but the one I read was Basic Computer Programming by [Theodore Scott] (Computer Programming Techniques was the title of a later edition). Keep in mind this was years before BASIC the computer language, so the title just meant “elementary.” This was an unusual book because it was a “TutorText” or what we would call now a programmed text — like a “Choose Your Own Adventure of computer programming.

As you can see, you’d read a bit of text, look at a problem and based on your answer, jump to another page. If you were wrong, the page would explain to you what you did wrong and usually offer another problem to see if you had it figured out. If you were right, you’d move on to a new section. You can read the whole book online and, surprisingly, if you were trying to learn to program from zero, I would highly recommend it. Sure, some of the content is way out of date, but the concepts are solid. The programmed text is probably best put on paper, so maybe this is one of those PDFs you print out. Or find a copy of the book in hardcopy, which isn’t impossible.

The inside covers of the book described the mythical machine, TUTAC. It had many features that became uncommon very early in the computer age. For example, TUTAC uses decimal numbers. Indexing occurs by having the program rewrite the target address of other instructions in the program. This used to be common before the inclusion of indexing registers. Fortunately, the scan of the book did scan the inside covers, so if you really want to read the book in PDF, you are set.

If you are one of the few people who’ve heard of TUTAC, there’s a simulator in Python. I was frankly surprised anyone else remembered this one, but there’s apparently at least two of us!


[Donald Knuth] wrote what would be the set of books for aspiring programmers of the day. The first volume from 1968 introduced MIX, a made-up machine that is a bit more modern than TUTAC. Because it was a widely-used book, many people learned Mix. There are quite a few Mix emulators today, including a GNU program.

[Knuth] actually was to write more in the series but he completed only three volumes at first. Part of the fourth volume appeared in 2011, and there were seven planned. Some drafts of other parts of the fourth volume are downloadable.

The MIX architecture is a bit more modern, but not modern enough. [Knuth] proposed MMIX to have a modern RISC architecture. In addition to emulators, there is at least one contemporary FPGA implementation of MMIX, so it really doesn’t qualify for this list.

MIX can use binary or decimal numbers but didn’t use a full 8-bit byte which means code that can work in binary or decimal can’t store numbers larger than 63 in a byte. There are nine registers and a fairly small instruction set. Like TUTAC, MIX programs often modify themselves, especially to return from subroutines, since the architecture doesn’t include a stack.

As an interesting point of trivia, MIX isn’t an acronym, but a Roman numeral. MIX is 1009 and [Knuth] averaged the model numbers of common computers of the day to arrive at that number.


We’ve talked about Blue before. It had a slightly different purpose than TUTAC and Mix. As part of [Caxton Foster’s] 1970 book about CPU design, it was really a model for how to build a CPU out of logic gates. However, it did have to be programmed and had an instruction set reminiscent of a DEC or HP machine of that era.

There is at least one software version of Blue out there and my own implementation in FPGA. I’m particularly fond of the front panel design (see video).