Bootstrapping, or “booting” a computer refers to the process of getting an initial program into a computer, so it can do something. Most often, it is a small program that does one thing, which is to load a larger, more capable program into memory and run it. Boot programs are always hardware-specific, because they have to know what the computer will do first when it starts, and have to permit the computer to access wherever the larger program is so it can be loaded. In some cases, the boot program just does whatever task you want the computer to be doing — this is common in microcontroller applications.
If we want to bootstrap our computer, we need to find a way to work with memory that doesn’t require the computer to be running. There are a number of ways to do this. Early Control Data Computers literally had some memory mapped to an array of switches;
but that gets expensive fast, and takes up a good deal of space for not much memory.
It’s much more common to use a pre-programmed Erasable Programmable Read Only Memory (EPROM) to hold an initial program, and pre define the system setup and I/O. This is basically the same as the switch solution above, only using much smaller transistor switches, affording a lot more memory. The Basic Input/Output System (BIOS) in your PC is a ROM with a boot program for your processor.
To change the program, you pull the Integrated Circuit (IC) out of the computer, erase it (usually with UV light), and write a new program using special hardware. While an efficient solution, it doesn’t really let us play with the boot process, or see what’s going on.
Early microcomputers used a “front panel” to provide access to the memory and microprocessor. It consisted of arrays of status LEDs and switches that afforded access to the machine’s status signals and Random Access Memory (RAM). My favorite example of this strategy is the Altair 8800;
a classic front panel. To use it, you set the memory address and data value with the switches, then press a button to load the data into that address. Lather, rinse repeat. I like this approach. It gets us direct access to memory, yet doesn’t require the microprocessor to be running. However, it has some problems with readability, and programming individual bytes with toggle switches is really tedious.
What I want is more like what I remember from my dad’s SYM-1;
seven-segment displays for address and data, and a hex keypad for entering values. This is a lot easier to read, and quicker too. But, when I dug into the manuals for the SYM-1, I discovered this functionality was due to the ROM monitor that handled the boot process, and drove an I/O chip for keyboard and display. It’s not really a front panel.
But it could be; all I’d have to do is work out a circuit to decode the buses and display them on the 7 segment displays, and a circuit to encode a hex keypad to set the buses, and I’d have a front panel without the pain of flipping toggles. There will be some issues with counting and latching so each keypress goes to the right place, but I don’t see any showstoppers with the idea. It will be more complicated than a basic front-panel, but simplicity isn’t a requirement. That’s what we’ll do.