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).
Of course, you can also account for widths like 15 and 27 as well as factors of six, if you consider the popularity of octal representation back in the pre-unix-epoch mists. Otoh, a lot of the earlier MSI chips supporter three or six functional units, so maybe octal was popular because of the tendency to groups of three bits. Hard to pin down the causality from 50+ years on, but these things seem interrelated.
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 …”
+1
+100
Seriously, guys, it’s the 21st century ! There are more fonts available ! And for a site that prides itself on hacking, is it really that hard to change the default font for a website ? Would you tolerate such ambiguity in an IDE while you are writing code ? How about on a component spec sheet ?
+1 or is that +l (lower case L)
When I was at Northwestern University in the 1980s, The main computing was done on a CDC 6600, with a 60-bit word. If I remember correctly, that could store 10 text characters, or 15 decimal digits (maybe).
By the time I graduated, it was considered extremely out of date, especially as it ran a custom operating system. This is because NU had a champion chest program that depended on that OS. When those researchers left for warmer climes, It was swiftly replaced with VAX/VMS.
Your mention of odd numbering schemes and “retro” implentations reminded me of that U. Penn project some years back to put ENIAC on a chip:
https://www.seas.upenn.edu/~jan/eniacproj.html
This effort included its base 10 number system.
Even today, a little weirdness persists. While most Forth processors were 16 or 32 bit, the MuP21 and its derivatives were 21-bit processors (with 20-bit wide external memory interfaces! the 21st bit only existed in the internal stacks) and its descendants, the GreenArrays chips, are matrices of parallel 18-bit processors with tiny amounts of memory; and all of their instructions are 5 bits wide. Chuck Moore was a staunch advocate of word-addressed machines before he retired from CPU design.