Al and I were talking about the IBM 9020 FAA Air Traffic Control computer system on the podcast. It’s a strange machine, made up of a bunch of IBM System 360 mainframes connected together to a common memory unit, with all sorts of custom peripherals to support keeping track of airplanes in the sky. Absolutely go read the in-depth article on that machine if it sparks your curiosity.
It got me thinking about how strange computers were in the early days, and how boringly similar they’ve all become. Just looking at the word sizes of old machines is a great example. Over the last, say, 40 years, things that do computing have had 4, 8, 16, 32, or even 64-bit words. You noticed the powers-of-two trend going on here, right? Basically starting with the lowly Intel 4004, it’s been round numbers ever since.
I wasn’t there, but it gives you the feeling that each computer is a unique, almost hand-crafted machine. Some must have made their odd architectural choices to suit particular functions, others because some designer had a cleaver idea. I’m not a computer historian, but I’m sure that the word lengths must tell a number of interesting stories.
On the whole, though, it gives the impression of a time when each computer was it’s own unique machine, before the convergence of everything to roughly the same architectural ideas. A much more hackery time, for lack of a better word. We still see echoes of this in the people who make their own “retro” computers these days, either virtually, on a breadboard, or emulated in the fabric of an FPGA. It’s not just nostalgia, though, but a return to a time when there was more creative freedom: a time before 64 bits took over.
Iirc, IBM owned 8 bit architecture and would sue every and anybody using it without the extremely expensive license they offered.
No they didn’t.
Ok, my healty daily dosis of desinformation :) I want to believe Scully!
The “factors of six” thing is almost certainly due to pre-ASCII character representation by 6 bits. That would be 64 characters, “enough for anybody”, and plenty for control characters, puctuation, numbers and upper case (lower case is just a distraction).
The CDC CYBER 74, on which I took my assembly language programming course, had 60 bit words and 6 bit character codes, IIRC. ASCII conversion for Teletype I/O took place in an auxillary “concentrator” called a Tempo (TEMPO Computers, 1971).
There are many other word sizes…
The commercially and academically (Tony Hoare’s seminal Algol60 compiler) important Elliott 803/903 has 39 bit words. See one running at TNMoC, and discuss the schematics with helpers there (my kind of museum). The 39 bit word contained two 18-bit instructions plus a strange modifier bit.
The ICL1900 series had 24-bit words (containing 4 bytes of 6 bits).
Motorola MC14500 was a 1-bit machine.
And I won’t include bit slice processors, because that would be cheating :)
The “weird” word sizes were a combination of the extreme cost of discrete circuits including odd implementation tricks, plus a “pre-Cambrian” style explosion of inventions, most of which have died out.
Odd implementation tricks include relatively complex logic gates based around magnetic core components – cheaper than Ge transistors!
Word lengths in the early days was actually pretty simple. Usually, the instruction also encoded memory addresses along with the instruction. Registers were really expensive, so outside of an accumulator and program counter and maybe or maybe not a stack pointer, everything was done as (usually) between the accumulator and some value in a memory location. So on a PDP-8, a typical instruction had 4 bits for the instruction and 8 bits for a memory location in a 256 word page. With instructions to jump between pages, you could address more memory. The other, more oddball word lengths you mention were similar, but with different constraints. The military guidance computers were often constrained by the desired precision of the integer instructions. They needed enough bits to get the resolution needed. To meet timing constraints, it was better to use a longer word with one memory fetch than to break it up into multiple ones.
With the IBM 360, that changed. It broke the link between the instructions and memory addresses. This allowed variable length instructions, allowing for more compact programs. Not to mention, more instructions could be encoded and more complicated instructions could be used, like the POLY instruction in Vaxen. By the time of the 360 tubes were out, transistors were in and the budget for active elements was relaxed. Using even powers of two simplified a lot of things in the architecture and removed potential bottlenecks in performance. Not to mention, it allowed the killing off of coding in octal which was popular on those 12, 18 and 36 bit machines…
And that also explains why it wasn’t until well into the 1970s that a byte was reliably 8 bits instead of, say 6.
3 bits for instruction, one for indirect, one for page zero vs current page, 7 bits for word within that page.
Hackaday needs a different font, or I’m gonna keep reading the first sentence of this article as “A[rtificial ]I[ntelligence] and I were …”