Can a retro-computer be a useful way to learn computer-architecture fundamentals?

Question

I've been reading about the fundamentals of computer architecture, but I think I could get a better grasp of the basics if I could could have an actual device to play with.

I had considered building a 2- or 4-bit device on a breadboard with "switches and blinky lights," but I think that a ready-made machine that I can interact with, code/decode, and disassemble/reassemble might be a better place for me to start.

Would a retro-computer, say from the the 70's or 80's, be good for this purpose?

FYI, I've been considering an original Apple II for many reasons, including its hobbyist-friendly design, a wealth of documentation, and a fondness for its main inventor, Steve Wozniak. But after seeing the high price of them on eBay, I'm considering other systems too.

Answer 1

The main benefit for learning computer system architecture with a retrocomputer, compared to a modern computer, is accessibility of the hardware. Retrocomputers are much simpler than modern systems in terms of both the hardware and the system software. By design and necessity, programming on a retrocomputer means often programming the bare metal, and that means understanding how the machine works in exquisite detail. At the same time, you get the aid of a big software library (often including a built-in BASIC interpreter) that shows off what's possible with the hardware, plus a fully self-contained environment to program in, plus a simple hardware architecture that can easily support hardware hacking too.

The commenter above makes a very valid point about Arduino, which also is designed for this sort of bare metal software hacking and building your own hardware add-ons. I think the thing you would miss out on is the fascinating history of the retrocomputers, and the fact that they are normally far more sophisticated than just the CPU+GPIO that you get with Arduino. Many retrocomputers have unique and powerful coprocessors for sound and graphics. At minimum, they all support basic peripherals like keyboard, mouse/joystick, and video display. You'd have to attach some primitive proxy for these I/O device to Arduino to make it a full, self-contained computer system that you can program or use stand-alone. Then again, for programming efficiency, having something tethering you to a modern device can be very helpful. And that is possible to do and equally easy with either Arduino or a retrocomputer.

The original Apple ][ is an expensive retrocomputer because it is rather rare and collectible. But you can acquire an Apple //e, //c, or IIgs for a much more reasonable price. Of all of these, the IIgs is the most sophisticated and probably offers the most long-term hacking potential. But you could get very far "down the rabbit hole" with any of them. And, I also think you'd be happy with other popular 1980s 8-bit machine like Commodore, Atari, IBM 5150, or Tandy (showing my North American persuasion). Regardless, be sure to get a machine that comes with or can be adapted to a video display that you have available, and also investigate the supported hobbyists projects that will help you move files and disk images between the modern world and your retrocomputer of choice.

Answer 2

I would say the answer to the question is no.There are two reasons for this.

Firstly, a retro computer is still a box with a circuit board in it and some chips soldered to it. Actually looking at its insides isn't going to leave you any more the wiser than looking at the insides of a modern desktop PC.

Secondly retro computers - well, 1970s and 80s era microcomputers won't teach you very much about computer architecture generally because they tend to be extremely crude machines. You could understand a Commodore PET's internal workings in a great deal of detail (and I do, having written an emulator) but it won't tell you anything about virtual memory, caching, multithreading, pipelines and any one of the many concepts that were omitted from it thanks to the extreme cost of adding them to a micro computer of the time.

The best way to understand a particular computer's architecture is to write (or build, if you are competent at electronics) an emulator for that computer. If you just want to understand how computers work generally, may I recommend a book: The Elements of Computing Systems: Building a Modern Computer from First Principles by Noam Nisan. It walks you through building a software emulation of a 16 bit computer from the basic TTL gates upwards. It does suffer a little from my second criticism in that it stops before you get to a discussion on things like virtual memory and it also incorrectly describes the architecture you build as a Von Neuman machine rather than what it is which is Harvard architecture.

Another useful exercise is to try to write answers for questions on here about computer architecture (you don't have to actually submit them if you are not confident). For example, researching this question or this one, will tell you a lot about how virtual memory management works in a lot of machines.

Answer 3

Yes and No.

Yes, retro computers can be useful to learn how a computer works (what components you need for a system to be useful, and how those components are connected together), but "Computer Architecture" as a topic requires you to understand many ways that systems may be put together and the pros and cons of each, and learning how any one retro computer works isn't an efficient way to reach that goal.

If you want to pursue this anyway, look for a system that supports processor and memory upgrades, as well as upgrading from slower disk systems to faster disk systems. Start with the minimum configuration and upgrade parts as you hit performance/resource limits so that you can see how upgrades don't really fix performance issues as much as they move system bottlenecks to a different part of the system. Unfortunately the best systems for this kind of thing aren't so easy to find nowadays (and parts you can use for upgrades even less so).

Answer 4

Yes, and countering the "still a black box" argument.

Hardware on the level of the original IBM-PC or AT is accessible as an electronic system to someone with "some" electronics skills and affordable tools: Connection points are big enough that they can be accessed with logic or oscilloscope probes. Most signalling is slow enough that probing it with test equipment will not create an RF mismatch so severe that the machine will crash. Most chip-to-chip I/O protocols follow the /CS, /WE, Address, Data scheme, and signals are "literal" - a presence of voltage on a data line means a data bit of 1. Faster, more modern hardware interfaces like SDRAM and DDR, USB, PCI-express, Ethernet tend to use complex encodings that also often do not allow you to interpret a logic state of a line "in isolation", data is mixed with status, synchronization, error correcting, housekeeping protocols on one wire (RS-232 serial had some of that, but in a MUCH simpler fashion, and still making it very evident what was data and what was metadata).

Measuring anything in the data paths of modern computers would mean using equipment that even as used surplus will cost hundreds to tens of thousands AND will be difficult to connect and use.

Also, most signalling used one common specification how voltages and currents were to be interpreted, often 5V TTL levels. There will be a couple of different physical layer protocols on a modern PC mainboard.

If you print a few lines of the letter "A" to a text-mode printer connected to a centronics printer and connected LEDs (in practice, use a buffer to do so!) to the 8 data wires on the parallel cable, you would see data lines 0 and 6 flash up a lot, any others staying nearly dark: 01000001 is the binary representation of ASCII "A".

The parallel port could thusly also be used to connect simple, customized real world hardware (eg to control machinery) that could be made from perfectly generic parts (literally from discrete transistors) - Doing that with USB without using some USB-specific parts would be very difficult.

From a software side, a programmer could literally take the datasheet (with programming documentation) of some I/O chip and go for it, without interacting with an abstracted device driver.

Answer 5

YES.

Well, I've grown up with the 8-bit Z80 machines, built a few hardware projects back then. The basic ideas what a CPU does are still valid even after 40 years, and many contemporary programmers lack that understanding.

So you're very welcome to learn the machine level of computing.

The old processors are good for learning the basics because they show you explicitly at their external pins what they are doing right now. A Z80 has 8 data bit pins and 16 address bit pins, and for every single read or write access that your assembly-language program does, you see the activity on these pins (plus the supporting control pins).

One manual was enough for the complete specification of a CPU, e.g. found at http://hartetechnologies.com/manuals/Zilog/Zilog_Z80_Technical_Manual.PDF

A typical step when booting up a new Z80 board design for the first time was to insert a ROM with the bytes C3, 00, 00 (meaning Jump to address 0000) at the addresses 0000 to 0002. This was expected to send the machine into an endless loop, repeatedly reading this Jump instruction. And you could easily see the expected memory read cycles using an oscilloscope. The Z80 manual told you exactly what this loop was expected to do:

• read the first byte (opcode C3) from address 0000 using a 4-clock M1 cycle

• read the lower half of the target address (00) from address 0001 using a 3-clock M2 cycle

• read the upper half of the target address (00) from address 0002 using a 3-clock M2 cycle

So the loop was to complete within exactly 10 clock cycles (if memory was fast enough, which was always true as far as I remember).

Modern CPUs have multiple cores, internal caches, out-of-order execution, opcode translation and many more features that make them as lightning-fast as they are, compared to a Z80. But they lack the possibility to see the processor working: our Jump-to-Zero loop would be read from memory once and then executed from the internal cache, totally invisible at the outside pins.

So if you're ready to spend some time, then building your own computer from the chips can be both fun and give you a deep insight into processing at the machine level.