It has been about 3 months, but we seem to have 128KW of memory on the CDC 6500 now.
From the picture you can see “CM = 303700”, which is just about 100KW free!
We have built 35 new Storage Modules, all of which work, and 32 of them are installed in the machine in place of Core Modules which were not happy. There are 10 more new Storage Modules in process, and the mostly assembled boards should be in next week. They will need their connector pins and pulse transformers installed. I will have to build more chassis sides and fronts for them, but that may take a while, as I still have 3 good modules, itching to go to work, sitting on my bench.
Something I find interesting in this photo, is the memory access patterns. It is hard to see in the picture, but bank 30 is at the top of chassis 11, and bank 34 is at the top of chassis 12. The left two LEDs in the new storage modules are the Read and Write indicators. The ones on chassis 12 are bright, and the ones in chassis 11 are off. The top rows are separated by 4 locations! The machine isn’t real busy, it just has two instances of a prime number program running, but still… Can’t see that with Core Modules.
Anyway, let’s see, both CPUs working: check! All of memory working: check! Real card reader working: check! Real tape drives working: oops, not at the moment. I guess I’m not done yet.
Our first floor ‘Tennis for Two’ exhibit has a new scope. Not really new though because chronologically it is lots older than the scope we were using. We had been using a Tektronix 465 scope which dates from no earlier than 1972. I remember this oscilloscope model well as I had one exactly like it on my bench at a previous job as ‘my scope’. The Tektronix 465 which had been displaying Tennis for Two was made at least 14 years after Tennis For Two had been invented. Not an ideal situation for a display certainly, but a lot better than no oscilloscope at all which was our alternative. It took a while to acquire and restore a period appropriate scope.
I wanted to use the same model oscilloscope which had displayed Tennis for Two when it made its debut at Brookhaven National Labs back in 1958 but which scope was it exactly? All I had to go on was this photograph.
The Tennis for Two oscilloscope is on the left side of the instrument stage. This next photo shows exactly where. This is actually two photographs photo-shopped together and the scope image detail portion was not photographed in 1958.
Enlarging a photo does not produce the detail shown above. The original photo is black and white and the enlargement is in color. Obviously two photos were combined. Beyond the obvious in the original ‘Blade Runner‘ movie Agent Deckard used a device which allowed him to zoom in on a photograph without loss of picture quality no matter what the magnification.
In real life that is simply not possible. In real life the ‘replicant’ from the Blade Runner movie would have lived another day safe from Dekard for this is what you get upon enlargement of our scope in the Tennis for Two photo. Loss of detail.
The photo is too fuzzy to make out the white DuMont label just below the display screen in the photo center or a model number. You can’t even tell where these labels are. I had to look at the photos of countless old scopes to make a match. It turned out the diamond pattern of the central knobs below the screen is very distinctive and only DuMont scopes of Dumont ‘304’ model type have that pattern. Upon identifying the type of scope it was I was able to find one on E-Bay and restore it. After physically acquiring the oscilloscope certain features in my fuzzy photograph such as the white DuMont Label made sense. Without a real scope to compare it to these features would have remained a mystery.
Restoration involved replacing almost every capacitor in the scope which could have age related issues before I turned it on. That is not all but most of them. Minor troubleshooting then was able to get the scope to work. The vertical Amplifier had a bad connection on a calibration switch which would not let the vertical amplifier signal pass. As we don’t need to use the calibration switch I simply bypassed the connection. If we were to ever calibrate this oscilloscope we would not use the internal calibration signal and would provide an external calibration signal anyway.
Here is the final result with the enlarged photograph I pasted on my office wall while I researched scope pictures. The shapes on some of the knobs are different but that is OK. DuMont mixed round knobs with pointed knobs of the ‘crows feet’ variety frequently. The scope we are using now and which I show here is an enhanced ‘304’ type called a DuMont 9559 and has options for doing RF measurements. I also acquired a plain Jane DuMont ‘304’ which has all crows feet type knobs. Physically the front panels are identical otherwise.
What matters most is not that the knobs absolutely match but that we now display Tennis for Two on a period appropriate oscilloscope. The scope I restored was in better overall condition between the two I had acquired and I suspect Brookhaven used top of the line models in their research. We really can’t know what the exact model used was so the Dumont 9559 is an appropriate choice.
Here is what has been going on on the CDC 6500: More Memory!
I’m sure the computer purity police will come and take me away, but this is what I have been doing. We are now up to 22 new storage module replacements, 17 of which you can see here. There are 3 more in chassis’s 9 and 10, and PP0 and PP1 each have one in chassis 1. I have 3 more to finish assembly of, when the parts come in later today.
Of the twenty units I have used in Central Memory, they are all involved in getting the First Location of banks 20 to 37 working, and that is all that works so far. If I try to test the second location, the first location fails. I don’t think the other three boards will get me through the second location, so I will probably be going out for more modules later today, or maybe next week.
My poor little milling machine has been working its bearings to the bone making Storage Modules sides and fronts. Since it doesn’t have “rigid tapping” (read automatic tapping), I started doing that by hand, but eventually I figured out a way to have the milling machine supply the energy to turn the tap, while I manually told it which direction to turn it.
So far, all the modules built have had the surface mount assembly done outside the Museum, and we have installed the pins and transformers. I may see about trying to convince other folks to do the through hole assembly and the machining.
Things are improving, we have moved from 65536 locations of memory to 65552 locations that work. Unfortunately it doesn’t work well enough to let the machine run with it out there, I still have to completely disable the upper 64K in order to have the machine boot.
The Alto proposal was a bold one, with a short time-frame and lofty goals. In a few short months, Chuck Thacker and the rest of the crew had designed and implemented a complete computer encapsulated in just a handful of circuit boards. The processor was comprised of two small boards (approximately 7″x10″) containing a mere 138 integrated circuits.
Peripheral controllers were similarly simple — single boards of the same size for each of the Display, Ethernet, and Disk.
How was such economy of hardware possible? Microcode.
Microcode and you:
In many computers from the Alto’s era, the architecture of the processor was hard-wired into the circuitry — there was dedicated hardware to fetch, decode, and execute each instruction in the processor’s repertoire. This meant that once designed and built, the computer’s instruction set could not be modified or extended, and any bugs in the hardware were very expensive to fix. It also meant that the hardware was more complicated — involving more components and longer development cycles. As processors became more and more advanced these limitations became more pressing.
Microcode and micro-programming helped solve these problems by replacing large swaths of control logic with software.
So What *is* microcode?
Microcode is software. It’s very low-level software, and it’s written in a language tailored to a very specific domain — the control of a specific set of hardware — but it’s software all the same. Let’s look at a small snippet of a program from the highest level, down to a microcode representation.
At the highest level, we have human language:
Add 5 to 6 and give me the result.
Which, if you’re able to read this blog, you are likely to understand the meaning of.
In a somewhat-high-level programming language, like C, this translates roughly to:
i = 5 + 6;
This isn’t too much different from the English statement above and if you’re familiar with programming or math at all, you can figure out that the above statement adds 5 to 6 and stores the result in the variable i.
In Nova assembly language, the above C program might look something like:
Now we’re starting to get a little bit further from the source material. This code consists of three memory locations (containing the operands and the result) and four instructions. Each of these instructions performs a small part of the “i=5+6” operation. “LDA” is Nova for “Load Accumulator” and loads 5 into Accumulator 0, and 6 into Accumulator 1.
“ADC” is Nova for “ADD with Carry.” It adds Accumulator 0 and Accumulator 1 together and stores the result in Accumulator 0. “STA” means “Store Accumulator” and puts the contents of Accumulator 0 (the result of 5+6) into a location in memory (designated as “I” in this example.)
In Alto microcode, a direct analog to the Nova instruction sequence above could be implemented as:
The number of instructions is larger (9 vs 4) and the microcode operates at a lower level than the equivalent Nova code.
The “MAR← FIVE” operation tells the Memory Address Register hardware to load a 16-bit address. The subsequent “NOP” here (and after every MAR← operation) is necessary to give the memory hardware time to accept the memory request. If this is omitted, unpredictable things will happen.
The “T← MD” operation puts the Memory Data register — the contents of the memory at the loaded location in the previous instruction — onto the ALU bus.
The “L← MD+T” instruction puts the memory data onto the ALU bus and tells the processor’s ALU to add the T register to it; and finally it causes the result to be stored in the L register.
What you may notice in the above examples is that the Nova machine language instructions tell the computer as a whole what to do (i.e. load a register, or perform an addition) whereas the Alto microcode instructions tell the computer how to go about doing it (i.e. “put this data on the memory bus,” or “tell the ALU to add this to that.”) It directs the individual components of the processor (the memory bus, the ALU, the register file, and the shifter) to perform the right operations in the right order.
So what components is the Alto processor made of? Here’s a handy diagram of the Alto CPU:
The nexus of the processor is the Processor Bus, a 16-bit wide channel that most of the other components in the Alto connect to in order to transfer data. The microcode controls who gets to read and write from this channel and at what time.
The R and S registers are 16-bit register sets; the R bank contains 32 16-bit registers, and the S register bank contains up to 8 sets of 32 16-bit registers. These are general-purpose registers and are used to store data for any purpose by the microcode.
The L, M, and T registers are intermediate registers used to provide inputs and outputs to the ALU and the general-purpose registers.
The ALU (short for Arithmetic Logic Unit) hardware takes two 16-bit inputs (A and B), a Function (for example, ADD or XOR) and produces a 16-bit result. The A input comes directly from the Processor Bus (and thus can operate on data from a variety of sources) and the B input comes from the T register.
The Shifter applies a shift or rotate operation to the output of the ALU before it gets written back to the R registers.
The MAR (Memory Address Register) contains the 16-bit address for the current operation (read or write) to the Alto’s Main Memory. Data is transferred to and from the specified address via the Memory Data Bus.
Each of the components above and their interactions with each other are carefully controlled by the microcode. Each microcode instruction is a 32-bit word consisting of the following fields:
RSEL selects the general-purpose Register to be read from or written to.
ALUF selects the Function the ALU should apply to its A and B inputs.
BS selects what source on the Processor Bus should be sent to the ALU.
F1 and F2 are Special Functions that control the shifter, memory, branching operations, and other operations.
T and L specify whether the output from the ALU should be written back to the T and L intermediate registers.
And the NEXT field specifies the address of the next Microinstruction. Unlike most conventional machine language where by default each instruction follows the last, Alto microcode must explicitly specify the address of the next instruction to be executed.
The Alto is similar to many other computers of its era in that it uses microcode to interpret and execute a higher-level instruction set — in this case an instruction set very similar to that of the Data General Nova minicomputer (which was popular at PARC at the time). The Alto’s microcode was also directly involved in controlling hardware — more on this later.
This means the earlier microcode example is contrived — it shows what an addition might look like in microcode, but not what the execution of the equivalent Nova assembly code example actually entails. So as to provide full disclosure, here’s the microcode instruction sequence the Alto goes through when executing a single Nova instruction, the “LDA 0,FIVE” instruction from the earlier code sequence:
Whew. That’s 13 micro-instructions to execute a single Nova ADC instruction. (Keep in mind that each micro-instruction executes in 170 nanoseconds, meaning that these 13 micro-instructions execute in about 2.2 microseconds, which is within spitting distance of the instruction time on a real Nova.)
The above sequence takes the current instruction, decodes it as an LDA instruction and performs the operations needed to execute it. If it doesn’t make a whole lot of sense at first glance, this is entirely normal. For the hardcore hackers among us, the above code sequence is taken directly from the microcode listing available on Bitsavers, the hardware manual is here and if you want to explore it in depth, you can use the ContrAlto emulator to step through the code line by line and see how it all works.
The Alto used microcode to simplify implementation of its processor. This was state-of-the-art at the time, but not altogether novel. What was novel about the Alto is its use of the processor’s microcode engine to drive every part of the Alto, not just the CPU. The display, disk, Ethernet, and even the refreshing of the Alto’s dynamic RAM was driven by microcode running on the Alto’s processor. In essence, software replaced much of what would have been done in dedicated hardware on other computers.
The Alto was also unique in that it provided “CRAM” (Control RAM) – a microcode store that could be changed on the fly. This allowed the processor’s behavior to be extended or modified at the whim of the programmer – while the Alto was running.
To allow the devices in the Alto to share the Alto’s processor with minimal overhead, the Alto’s designers developed very simple cooperative task-switching hardware.
Conceptually, the processor is shared between sixteen microcode Tasks, with a priority assigned to each one: Task 0 is the lowest priority task, and Task 15 the highest. Each device in the Alto has one or more tasks dedicated to it. To make task switching fast and cheap to implement in hardware, the only state saved by the task-switching hardware for each Task is that task’s program counter — the MPC (“Micro Program Counter”).
Only one task is running on the processor at a time, and at any time the microcode for a task may invoke a “task switch” function (named, strangely enough, TASK). When a TASK instruction is executed, the processor selects the highest priority task that needs to run (is “Requesting Wakeup”) and switches to it by jumping to the instruction pointed to by that Task’s MPC.
The Emulator Task (Task 0) is always eligible for wakeup but runs at the lowest priority and which can be interrupted at any time by hardware that needs attention. As suggested by the name, this task contains microcode that “Emulates” the Nova instruction set — it fetches, interprets, and executes the instructions for the user software that runs on the Alto.
The Disk Word Task (Task 14) is the highest priority task implemented in a standard Alto. It needs to run at the highest priority because its main job is pulling in words of data off the Diablo 30 disk drive as they move under the read head.
The Display Word Task (Task 9) is responsible for picking up words out of the Alto’s memory and painting them on the display as the CRT’s electron beam moves across the screen.
Since the Alto’s Task system is cooperative (meaning that task switches only happen when microcode explicitly requests them) the microcode for each task must be careful to yield to other tasks every so often so that they don’t get starved of time. If the Disk Word Task is late in execution, data from the disk is corrupted. If the Display Word Task doesn’t get enough time, the display will flicker or display glitches. And since the Alto hardware saves only the MPC for each task, each task’s microcode must make sure that any important state is saved somewhere (for example, the 32-general purpose R registers) before the task switch happens.
This puts some interesting constraints on the microcode (and results in much hair-pulling on the part of the micro-coder) as you might imagine. But despite these limitations, and despite the extremely low-level details the microcode has to deal with, the wizards behind the Alto’s design managed to fit microcode implementing the basic Nova instruction set (with extensions for graphics operations), disk controller, Ethernet controller, display, and memory tasks into a 1,024 word microcode ROM. With three words to spare.
The Task-based microcode architecture, in tandem with the writable microcode Control RAM (CRAM) made the Alto a very flexible computer — new hardware could be quickly implemented and added, and the microcode to drive it could easily be loaded and debugged. Entirely new instruction sets were devised, experimented with, and revised quickly. Applications could load custom microcode to accelerate graphics rendering.
In the next article, we will go into depth on the rest of the Alto’s hardware.
I have been worried that I would have to re-manufacture a module because I just couldn’t fix it. The time has come! I found this PZ module in chassis 10, while chasing memory problems. This one causes all 6 bits that go through it to fail my tests. I have traced it down to what appears to be an open base on Q26, which I have circled in the picture. OK, what’s the problem? Q26, as you can see is in the middle of the card. When I have had to replace middle transistors in the past, the front bracket has been held on with 6 little 2-56 screws. You don’t see any screws on this module other than the ones that hold it in place, do you?
This module coming from chassis 10, means it is newer, since Purdue upgraded from 64K to 128K several years after they got the machine. Instead of screws, this module is riveted together, and the rivets are soldered, as are most of the modules in Bay 3 which holds chassis’ 9-12.
Update: I managed to get it far enough apart to change the offending transistor, and failed to break it completely, so now it works, without the 3 weeks of my time to re-manufacture it, not to mention the 3-4 weeks for the manufacturing process to actually produce the replacement.
On my to-do list has been the task of eliminating jittery text on our TRS-80 model 1 video monitor displayed in the second floor vintage collection of personal computers. The display show a,
prompt as it waits for user input. Our problem is that the prompt rapidly vibrates back and forth making the prompt nearly illegible besides being simply annoying. the monitor acts like it has been drinking massive amounts of coffee and is on a serious caffeine buzz.
The screen vibrates because interference produced by a TV used as a monitor in an Atari 400 exhibit placed directly behind the TRS-80 video monitor is turned on. Turning off this Atari 400 exhibit monitor makes the TRS-80 display jitter vanish. The Atari and TRS-80 exhibits are back to back from each other in separate rows of our personal computer display. They are separated by enough distance that signal interference should not be a problem.
Other arrangements of the many computer/monitor combinations in our personal computer exhibit were placed behind the TRS-80 video display and these other monitors produced the same interference as the Atari 400 TV does. That other monitors from other systems produced the same jittery result shows that the problem lies with the TRS-80 monitor and not the other monitors. This monitor is apparently too sensitive to low frequency magnetic interference produced by other monitors if they are placed a couple of feet away.
We had discovered that a bare aluminum plate (made for a rack mount enclosure cover) about a tenth of an inch thick, totally stopped the jittery text when placed several inches behind the TRS-80 model 1 video monitor. The plate needed to be in between the TRS-80 display and the interfering monitor and placed in exactly the right place to be effective.
The aluminum plate solution suggested that lining the inside of the TRS-80 video monitor cover with copper foil and tape should also eliminate the jitter problem. I attempted to do this both with and without a ground lead to the added copper foil shielding. Both my attempts were a miserable failure. The foil tape has conductive adhesive between layers but apparently the resistance between sections was still too high to allow sufficient eddy currents to form which would stop the magnetic field from penetrating into the video monitor electronics. That is my supposition and the story I was telling myself but before attempting to improve the shielding I decided to find out more about the TRS-80 display.
It turns out that the TRS -80 model is actually a modified RCA TV made in 1977. I found a picture of the particular model.
Comparing this with a TRS-80 Model I video monitor the connection is obvious.
The tuner from the original TV set was removed in the conversion. A circuit board that buffers the video signal from the TRS-80 was put in its place. There is a connector for the tuner on the main TV circuit board and the replacement board simply plugs into this location.
Having seen the insides of enough old TVs, tuner sections were always wrapped in sheet metal to prevent interference. However, this precaution (and necessity) was not observed when replacing the tuner with the TRS – 80 video display custom circuit board. It appears no consideration was given to making this circuit board noise immune. The typical things I know which should be done to make a noise immune circuit board were not done.
I could modify the circuit board so the problem pretty much goes away but I need schematics to do that. Currently we do not have any. I would adjust impedances so the relatively weak interference signal is effectively shunted to ground. I would essentially be finishing an unfinished job from 1977. An alternative would be to mount the aluminum plate solution permanently and document why it is there for visitors.
Upon sharing my findings with the museum staff, it was decided I should work with Aaron Alcorn and implement the aluminum plate solution. I met with Aaron at our second floor exhibit. I explained that the problem was dependent on height and that lifting the TRS-80 display off its base would make the problem go away. The TRS-80 display had been sitting on a plastic base to elevate it a few inches above the TRS-80 keyboard for easy viewing. Aaron immediately lifted the display and removed the elevating platform. This had not been tried before. The problem immediately went away. Aaron solved the problem in ten seconds.
It turns out the elevating platform was not all plastic. On its top was a thin layer of steel sheet metal. This sheet metal had been coupling interference into the video display. I think my supposition that the TV to TRS-80 computer monitor conversion had not been fully worked out is still correct but it is also true that placing a TRS-80 monitor in close proximity to another monitor on a steel table was not a typically anticipated operating environment for a TRS-80 computer monitor. The TRS-80 had been intended to be used as a home computer all by itself.
In a karmic twist to this story the TRS-80 model 1 was discontinued because it could never be made to pass FCC RF emission standards. About 250,000 Model 1 systems were produced before it had to be discontinued, five times the original sales target.
The TRS – 80 was an antisocial computer not designed to be used around other computers. It was electrically noisy itself yet also hypocritically overly sensitive to electronic noise from other computer monitors. It was however a very early personal computer and exposed many people to computing for the first time. That is its particular historical significance. I remember it originally used large 8 inch floppy disks in its original floppy drive. As smaller 5 ¼ inch floppies had been introduced in 1976 I found that strange, but I suspect at the time it was the cheaper way to go.
It has been said that the TRS-80 computer did everything ‘OK’ but nothing really really great. It appears that the particular video monitor design issue we discovered supports this view. But while it may have been flawed, the TRS-80 was also affordable and brought the joy of computing to many for the first time.
Here at the LCM+L Skunkworks, some of the folks have been working on a Little Punched Card reader, so Visitors can see what they punched in their punched cards. Jeff and Hunter have been working on the electronics, while I have been building mechanical parts for them. Here is a picture of where it is today:
You can see it is made from clear plastic, so you can see EVERYTHING. This being a prototype, it has a few warts: like those extra holes in the sides. I had never actually used the boring head with my milling machine, so I had to figure out how to use it. Boring heads are used to make round holes, usually larger than you can get with drills. Yesterday, I made some new side plates, sans extra holes.
I started by drilling the holes for the 6-32 screws that hold the thing together:
Once I had the holes in, I had to put in the bearing holes, this is where the boring head comes in. I have drills up to 0.500″, and a 0.750″ one, but the bearings are 16mm in diameter, or about 0.630″. I start to drilling the bearing holes to half inch:
Then I have to bore out the holes to 0.630″ with the boring head:
The gray part moves to adjust the size of the hole, here is a picture of the business end, where I can adjust the size of the hole it makes by 0.001″:
After I added the holes to hold the motor mount, and a bunch of filing edges, here are the two sides, sitting on Jeff’s desk:
I mentioned that I was doing this on my milling machine. If you don’t know about milling machines, they are basically like a very rigid drill press, with a movable table to hold the part you are working on. I can move the table around very precisely to get the holes Exactly where I want them. You can also work on the sides of the parts with special cutters, which is how I got the plates to the basic shape. Here is a link to what my milling machine started out life as: http://www.grizzly.com/products/Mill-Drill/G0463. It was smallest machine that I felt could be called a real milling machine.
Going out for 20 more Storage Module replacement boards today. All 5 of the first run work with one timing change, and different values for 12 resistors.
Over the last week or so, I have fixed all the bad PS and PZ modules that I had previously identified. The machine has been running with all those replacement modules, as the first 5 PP’s for more than a week now.
It’ll take a week to fab the boards, and a week or two to do the surface mount assembly, then David Cameron and I will install the connector pins, and pulse transformers. Then I will be off to fix the other half of the memory to bring the machine up to his full 128K words.
In this series of articles I’ll go into the Alto in detail — the low-level hardware implementation and microcode, the software and languages and ideas that this hardware made possible, and the environment at Xerox PARC where the Alto was designed and used. But before we dive down to the bedrock, let’s start with a bit of background.
In the early 1970s, Alan Kay, a computer scientist at PARC, had a vision of a personal portable computer that he called the Dynabook. In many ways, Dynabook was similar to modern laptops or tablets – it weighed under two pounds, contained a keyboard, display, and pointing device, and had a tablet form-factor. The goal of the Dynabook was to be “a personal computer for children of all ages,” a portable educational computer. Kay’s vision wasn’t technically feasible at the time – but the vision behind it was a driving force for the research he lead both during his tenure at PARC and beyond.
In 1972 Kay proposed the idea of building a small personal computer (which he termed “KiddiComp”) to allow experimenting with the kinds of ideas he envisioned for the future Dynabook – in particular user interface design, education and computer-literacy for children. This was centered around a programming language he called “Smalltalk” which made use of unique hardware for the time: A high-resolution bitmapped display with a pointing device. Unfortunately, when Dr. Kay submitted a proposal to the management at PARC to get a few KiddiComp systems built, he was denied funding.
Enter Butler Lampson and Chuck Thacker. When PARC’s request for the purchase of a DEC PDP-10 for their research work was turned down in 1971 these two brilliant engineers figured they could design and build their own PDP-10 within eighteen months. And they did – MAXC (pronounced “Max”) was a microcoded recreation of the PDP-10 architecture using semiconductor memory rather than core, and a pair of them were used at PARC for the next decade. By 1972 Lampson and Thacker were both itching for a new project.
In Sept  … Butler and Chuck came over and asked: "Do you have any money?" I said,
"Yes, about $230K for NOVAs and CGs. Why?" They said, "How would you like us to build
your little machine for you?" I said, "I'd like it fine. What is it?" Butler said:
"I want a '$500 PDP-10', Chuck wants a '10 times faster NOVA', and you want a 'kiddicomp'.
What do you need on it?" I told them most of the results we had gotten from the fonts,
painting, resolution, animation, and music studies. I asked where this had come from
all of a sudden and Butler told me that they wanted to do it anyway, that Executive "X"
[the executive who shot down Kay’s KiddiComp request] was away for a few months on a
"task force" so maybe they could "Sneak it in", and that Chuck had a bet with Bill Vitic
that he could do a whole machine in just 3 months. "Oh," I said.
Thacker and crew started the skunkworks project on November 22, 1972 and by April of 1973 the first Interim Dynabook (aka Alto) was up and running and displaying graphics:
The Alto featured a bitmapped display of 606×808 pixels with the approximate dimensions of an 8.5”x11” sheet of paper, 64KW (in 16-bit words) of semiconductor memory, a microcode clock rate of 170ns (approximately 6Mhz) and local storage of 2.5MB on a removable pack. In 1974 the design and implementation of Ethernet networking was completed, and became standard Alto hardware. All of this was implemented in a couple hundred ICs and fit under a desk. Over the next 10 years, approximately 2,000 Altos were manufactured for use within PARC and at research labs and universities around the world.
The Alto was designed as a research vessel for efforts within PARC, and in that regard it was an astounding success. Over the next decade, the Alto was involved in experiments in:
Programming languages (BCPL, Smalltalk, Lisp, and Mesa)
Networking and distributed computing
Desktop publishing, word-processing and laser printing
The Graphical User Interface (GUI)
Computer-generated music and audio
Computer-generated graphics and animation
Computer-aided circuit design
Most famously, the Alto (running Smalltalk) served as the inspiration for the modern Graphical User Interface. As the story goes, in 1979 teams from both Apple and Microsoft saw what PARC had been working on and were inspired, integrating aspects of what they saw into the Macintosh and Windows, respectively.
Smalltalk was important in early computer education and HCI studies and lives on to this day in the Squeak programming language.
The Mesa programming language originated on the Alto and was instrumental in the development of the Xerox Star desktop environment.
The Bravo word processor introduced WYSIWYG editing to the world and is in many respects the great-grandfather of Microsoft Word – Bravo’s author Charles Simonyi took what he’d learned from Bravo with him to Microsoft when he left PARC in the early 1980s.
The Ethernet networking research done with the Alto at PARC lead to the definition of Ethernet as an industry standard and was a major influence on the design of TCP/IP and associated networking protocols.
The Alto’s success was due in no small part to its clever, minimalist hardware design. This design made the Alto extremely flexible and easily adaptable to whatever crazy idea or experiment that needed to be investigated.
In the forthcoming articles in this series, I will go into detail about the Alto’s hardware and demonstrate how the Alto achieved this flexibility.