Little Card Reader

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.

CDC 6500 Memory, Again.

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.

The Xerox Alto: An Introduction

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.

Alto History

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.

Alan Kay's Dynabook. Image courtesy of Wikipedia.
Alan Kay’s Dynabook. Image courtesy of Wikipedia.

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.

From Alan Kay’s “Early History of Smalltalk”:

In Sept [1972] … 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 first Alto. From Alan Kay's
The first Alto. From Alan Kay’s “Early History of Smalltalk.”

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:

  • Human/Computer interaction
  • Education
  • 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.

 

CDC Printing

We now have the printer emulation capable of printing direct to our Dataproducts BP1500! We won’t have that turned on normally, but with a command to our emulator PC, we can have a job print to the printer, or otherwise, it will print to a file.

I keep the print files around for about a week, so if you want something you printed, I can email it to you, just let me know your user number (name) and about when you printed it, and Your printout can be on it’s way to you.

If you REALLY want hardcopy, we can do that now too!

Bruce Sherry

CDC 6500 Memory: First Production in!

The first 5 final candidate Memory module boards came in from FAB and Assembly yesterday morning, and they look pretty good! I reclaimed and installed more pulse transformers, bolted it onto the Lexan chassis I finished over the weekend, and plugged it in.

Hmm, I must have done something seriously wrong, because it seems to work! The top one, playing the part of PP0, is the new one, and the lower one, playing the part of PP1, is the prototype. The prototype has to be on extenders, because the connector spacing isn’t quite right. I seem to have gotten that corrected in the new version. You may be able to notice that the old one has the old logo in the lower left, whereas the new one has the new logo.

So, what did I do differently you may ask? Besides fixing the connector spacing, I added a whole bunch of test points, had them install the correct 0805 LED’s, as opposed to the 1206’s I put on the prototype, and reduced the LED current by a factor of 3 so I don’t get sunburned quite so easily.

I suspect there will be more assembly in my future.

Bruce Sherry

Apple 1 INTEGER BASIC #2

Okay, if the Apple 1 computer does not have screen addressing, how am I doing SPIROGRAPH?

7000 REM SET PIXEL (X, Y) 0-39, 0-47
7010 Z = 1 : Q = V(10*(Y/2)+X/4+1) * 2
7020 FOR S = 1 TO 4 – X MOD 4
7030 Z = Z * 4: Q = Q / 4
7040 NEXT S
7050 Q = Q MOD 4: Z = Z / 4
7060 IF Y MOD 2 = 0 THEN 7080
7070 IF Q MOD 4 = 0 THEN V(10*(Y/2)+X/4+1) = V(10*(Y/2)+X/4+1) + Z: RETURN
7080 IF Q MOD 4 = 0 THEN V(10*(Y/2)+X/4+1) = V(10*(Y/2)+X/4+1) + Z * 2: RETURN

8000 REM PRINT SCREEN 40 * 48; TBTBTBTB
8010 FOR Y = 0 TO 23
8020 FOR X = 0 TO 39
8030 IF Y = 23 AND X = 39 THEN RETURN
8040 Z = V(Y * 10 + X / 4 + 1) * 4
8050 FOR S = 1 TO 4 – X MOD 4
8060 Z = Z / 4
8070 NEXT S
8080 Z = Z MOD 4
8090 IF Z = 3 THEN PRINT “:”;
8100 IF Z = 2 THEN PRINT “‘”;
8110 IF Z = 1 THEN PRINT “,”;
8120 IF Z = 0 THEN PRINT ” “;
8130 NEXT X
8140 NEXT Y

As the screen is 40 x 24 characters, it would be nice to make that 40 x 48 — using ‘ , and : to double vertical resolution.

First I made an array of 240 integers.  It would have been nice to make an array of 40 x 48 integers, but there isn’t enough memory, and two dimensional arrays are not supported.  So I had to fit two vertical dots and 4 horizontal dots into one integer.  Then, using shift-by-divide and the MOD function, I could calculate what I wanted on the screen, and finally print it all out at once.  However, I didn’t print out the last character, as that would have scrolled the screen.

Spirograph is round, so the 48 lines vertically are not needed.  And, this is important, because the program actually loads, but does not run — getting an out-of-memory error.  Deleting some of the many REMarks frees up enough space to run.

Apple 1 INTEGER BASIC

If the Apple 1 computer came with INTEGER BASIC, then how am I doing BIORHYTHM?

9000 REM SIN/COS (DEGREES) INPUT A, OUTPUTS S, C
9010 S = ((A MOD 360)+360) MOD 360: REM GET ANGLE 0-359
9020 IF S < 180 THEN 9060
9030 IF S < 270 THEN 9050
9040 C = C5(S-270+1): S =-C5(360-S+1): RETURN: REM 270-359
9050 C =-C5(270-S+1): S =-C5(S-180+1): RETURN: REM 180-269
9060 IF S < 90 THEN 9080
9070 C =-C5(S-90+1): S = C5(180-S+1): RETURN: REM  90-179
9080 C = C5(90-S+1): S = C5(S+1): RETURN: REM   0-089
9800 REM SET UP TABLE
9810 DIM C5(91)
9820 S=0: C=8192
9830 FOR A = 0 TO 45
9840 C5(A+1) = S: C5(90-A+1) = C
9850 S=S+((C/3)*10)/191
9860 C=C-((S/3)*10)/191
9870 NEXT A
9880 RETURN

First I set up an array to hold SIN for 0 to 90 degrees.  (You don’t need more if you know COS is SIN of the angle plus 90, and other quadrants are symmetrical).

But, creating an array of 91 values would pretty much take up all of available programming space, so I generated it using the differential equations — relating SIN and COS.  I also made the values go from 0 to 8192, as going from 0 to 1 is not useful.

 

Apple 1 BASIC

INTEGER BASIC for the Apple 1 computer is not well documented.

Here are some things I found:

A FOR loop will always execute at least once.  This is unlike most BASIC machines, which will not execute the innards of FOR I = 1 TO 0.

Although the exponentiation symbol is recognized (^), don’t use it — that is a lock-up condition.

IF statements will execute a command.  However, multiple commands on the same line are not contained within the IF result.  That is, IF X > Y THEN A = 0: GOTO 1230 will always go to 1230.