More Blinking Lights (and a disgression)

In Blinking Lights I told you about how I feel the modern computer for its exterior, except for its screen, is boring. When I look at my Antec case, I see a large, silent black box, which, by its very definition, is uninteresting at best. Something like a rock that slowly dissipates heat.

However Bill Buzbee built a computer that has an interesting exterior, and a much more interesting interior: the Magic-1. The Magic-1 is a computer running at 4.something MHz, and is in the same computational power range as the original 8086 4.77 Mhz IBM PC, except with a more advanced instruction set.

The Magic-1 Computer

The Magic-1 Computer

In his own words:

Magic-1 is a micro-coded minicomputer running at 4.09 Mhz and is in the same ballpark as an old 8086 in performance and capabilities. It supports user and supervisor modes, address translation via a hardware page table, six external interrupts and up to 8 MB of memory (currently has 4 MB). Each process has up to 128 Kbytes of addressing, broken down as 32 pages (2K) of data and 32 pages of code mapped via the page table onto the 23-bit physical memory and device spaces.

But what makes the feat really impressive, is that the computer is built out of wirewrap. You have to admit, the guy has guts to build his own wirewrap computer. Wirewrap and breadboards are the most masochist tools of development there is in electronics, short of poking your eyes with a welding iron. I did wirewrap a couple of times for tiny itty bitty projects and it was always a pain to get to work properly and reliably… That someone can pull this one off really impresses me.

Although I do not have the nostalgia of sub-GHz processors, I must say that I think I understand his endeavor, in the same way I understand a climber to climb a mountain because it’s there. I find myself musing, from time to time, how I would design the perfect orthogonal instruction set so we’d all finally see the end of the never-ending x86 era. While it’s not going to happen any time soon; it doesn’t keep me from wondering what instructions I would take, and more importantly, those I could leave behind because, in the end, they serve little or no purpose. Instruction set design is this delicate balancing act between RISC and CISC. You obviously have to know enough about how software and compilers interact to offer the correct, useful, needed instructions, not an easy task.

For example, would you have a rnd instruction that generates a pseudo-random value from a register or memory location? Something like:

random: rnd [seed]
        mov [seed],eax

Or maybe a hash instruction? What about:

      xor eax,eax
      ; source ptr in esi
      ; count in ecx
      hash eax,byte ptr [esi]
      inc  esi
      dec  ecx
      jnz  hash_loop

or worse:

     xor eax,eax
     ; source ptr in esi
     ; count in ecx
     rep hashsb
     ; result in eax

Would they even make sense? If both were very well designed, maybe, but history made it clear: a better random generator and better hash functions always show up about 2 minutes after yours are published. I am sure that those two instructions would feed months of bitching and flaming on programmer fora, with revival every six months as new programmers join the show. I think we’d be much better off with a simple instruction set—not painfully minimalist, just simple—that would be a good trade-off between usability and versatility while offering all of the comfortable amenities of modern computing like complex addressing modes, protected mode, and virtual memory.


* *

Be sure to browse Buzbee’s homepage and

Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out /  Change )

Google photo

You are commenting using your Google account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s

%d bloggers like this: