Glenn’s Computer Museum

Early 9020 versions used System/360 Model 50 processors for all six processors, but our console comes from the latest 9020E version which used three Model 65's for "compute elements" and three Model 50's for "I/O control elements". Our control console is from one of the Model 65 computers, and is slightly different than the standard Model 65 console.

A quick deviation to discuss the IBM System/360. While technically obsolete now, the introduction of the System/360 family was a seminal event in computer evolution. The instruction set architecture was the most modern for its day and had many influences on current architecture (such as 8-bit bytes and 32-bit words). It also introduced a new I/O approach: a high-performance and programmable "channel" that could attach a vast and diverse set of I/O devices. The most significant feature was the concept of a family of computers, all having the same instruction architecture but with different performance and capacities, and all using the same I/O devices. Initially six models were announced: the Model 30, the Model 40, the Model 50, the Models 60 and 62, and the Model 70. These covered a performance range of about 100:1 and ranged from microprogrammed eight-bit datapath to hardwired 64-bit datapath. Yet they all ran the same software and used the same physical I/O devices.

Another eight model types were delivered during the System/360's lifetime, including the highly influential Model 67, Model 85, and Model 91. As a result of the technical features and especially the scalability and software compatibility across the family, the System/360, and its follow-ons such as the System/370 family, dominated the mainframe business.

The 9020 system had an abnormally long lifetime; the corresponding System/360 commercial products were withdrawn from sales in 1977, but the 9020 lingured in use until the early 1990's. One reason for this long life is the fact that much of the air traffic control application was written in System/360 assembly language. Another factor is the 9020's specialized radar console interfaces. As an example of the 9020 staying power, here's a scary NTSB report from 1996 about ARTCC outages pointing out that some of the ARTCCs are still using the 9020's at late as 1995! This reports discusses problems such as aging components where "replacements can be obtained only by scavenging parts from the [FAA] training computer". Thirty years is a long time for any complex equipment to remain functional, but in the world of computing technology, thirty years is many many generations of architecture and technology. Consider, as one example, that the 9020's used magnetic core memory and that a Model 65's performance was less than 1 MIPS!

Our 9020E console originally came from this site which has lots of other old IBM stuff. Stanford also has a 9020 master control panel, shown here, and the Smithsonian Air and Space Museum has one also.

(Note that on our console the original IBM 705 banner has been replaced with a customer's banner ("Confederation Life"). Since computers were so rare in the 1950's they were usually proudly displayed in a "glass house" by their users, often with the user's name on them.)

The IBM 705 architecture was heavily optimized for business applications such as billing, payroll, accounts receivable, and inventory control, as opposed to computationally intensive applications. In early computers, hardware was so expensive and limited in capability that the each computer was specifically designed for certain types of applications, with a common differentiator being character handling vs. arithemetic computation. In the 1950's IBM introduced several 700-series computer starting with the pioneering IBM 701. The IBM 702, IBM 705 were optimized for business applications, while the IBM 704 and IBM 709 were optimized for engineering and scientific applications. Shown on the left is a pre-System/360 "family tree" drawing from IBM of its early computers which illustrates the various model and their introduction dates. This application optimization continued through later transistorized descendants of these 1950-era computers (such as the IBM 7080 which was the follow-on to the 705) until the introduction in 1964 of the IBM System/360 family, which had a "general purpose" architecture. Even after that, low-end IBM computers such as the IBM 1130, System/3, System/32, and System/38 were optimized for specific applications. And, process-control applications were addressed by the specialized IBM 1800, IBM System/7, and IBM Series/1 families.

The IBM 705 used vacuum tubes (about 1,700 of them) for its logic and used magnetic core memory for storage. Its instruction-set architecture was heavily optimized for business applications. Of special note is the fact that memory was organized into 7-bit "characters" and the two accumulators (corresponding to current processor registers) each contained 256 characters. The memory size was either 20,000 or 40,000 characters. A load from memory into the accumulator took about 17 microseconds. The main input and output was magnetic tape (5M characters per reel), but a card reader and punch as well as a printer could be directly attached.

In addition to the control console, we also have some electronic components and original documentaion (some probably rare) for the IBM 705. We have several of the pluggable processor logic elements as shown on both sides along with an ad for the IBM 701 showing the same type of pluggable unit. Also shown is our stack of more than 25 original IBM documents about the 705 including the introductory volume of the Customer Engineer (CE) internal documentation. This document describes the details of the logic elements and memory components.

The microcode was contained in a control store implemented as read-only storage, or ROS (this is IBM's term, today we call it read-only memory, or ROM). Then, as today, ROS is implemented as a two-dimensional array of word-lines, which select the output for a particular address, and the orthogonal bit lines which are the outputs. Since only one word line is active at a time, the output for each bit of selected the ROS word can be defined by either no connection at the intersection of the word-line and bit-line, or by connecting the word line to the bit line through a diode. That is, when a bit-line is asserted, the output of the ROS is defined by the connects or no connects to the bit lines for that particular address. The difference among the many implementations of ROM are primarily in the choice of this connection mechanism. Different types of "diodes" affect the speed, size, and ability to change the ROS.

All except the high-end model of the original introduction used microcode to implement the System/360 architecture. Three different types of ROS were used: Card Capacitor ROS, Transformer ROS, Balanced Capacitor ROS. We have samples of all three of the types. Figure 1 shows a storage card of the Model 30's Card Capacitor ROS. The storage card looks like an IBM punched card except it is made of Mylar and has metal lines etched on it. (Much more about this ROS design can be found in J.W.Haskell,Design of a Printed Card Capacitor Read-Only Store, IBM Journal, March 1966.) Figure 2 is a closeup of the card. Each card has 12 word lines corresponding to the 12 rows on a standard punched card. The contacts for the word lines are on the right in the picture. Each word line attaches to 60 bit "pads" (again corresponding directly to the punch positions in a standard IBM card). The metal pad can be eliminated by punching that position with a standard card punch. Thus, bits in the microcode word for each word line are defined by the metal pad being present or absent.

The ROS cards are placed in a frame where bit lines run vertically aligned with each of the 60 column. A thin sheet of Mylar goes between the card and the bit lines to form the capacitive coupling between the metal pad and the word line. The cards are mounted on a 20x12" board with four cards on each side. The mechanics of the boards (ground planes, pressure on the card, insulator thickness, etc.) are such that the coupling ratio between a punched and unpunched pad is at least 10:1. The boards are assembled into a module to form the complete ROS. The Model 30 ROS used 43 boards for a capacity of 4032 60-bit words (with one spare board). The access time for this ROS is 0.75 microsecond.

It was relatively easy to change ROS cards in installed systems. This flexibility was important because the Model 30 had an option to emulate the machine instruction set of the very popular IBM 1401. Figure 9 (taken from another source) show IBM Field Engineer changing the ROS for a Model 30.

Figure 3 show the code portion of a module from the Model 40 Transformer ROS. Instead of a capacitor forming the connection between the word line and the bit line, the TROS used a transformer at the intersection. Figure 4 is a closeup of one of the Mylar strips containing two 54-bit ROS words. The word line is etched on the strip and completes a loop from one end back to the same end. The current is routed in one of two ways around a central metal core for each bit. The current direction around the core determines whether it is sensed as a 0 or 1. The current direction is controlled by punches that disconnect one side of the current loop around each bit post. (Much more about this ROS design can be found in D.M.Taub,The Design of Transformer (Diamond Ring)Read-Only Stores, IBM Journal, September 1964.)

Figures 5 & 6 show the "bit line" sensing mechanism that sits on top of the metal cores for each bit. Each module has 128 tapes, each storing 2 words. A total of 16 modules formed the ROS for the Model 40, for a total of 4K words. The access time was 240ns with a cycle time of 625ns. Figure 8 shows 8 modules of the Model 40 ROS; another 8 modules are behind the visible ones.

Figure 10 is part of the Balanced Capacitor ROS of the IBM System/360 Model 50. It is called balanced because the capacitance load on the word line is the same regardless of the pattern of bits. This is as opposed to the Card Capacitor ROS shown in Figure 1 where the number of 1 bits changes the word line capacitance. The balanced approach allows a faster access time: the timing of the Model 50 was 90 ns access and 200 ns cycle. The disadvantage of the balanced approach is that the bit patterns have to be manufactured into the card, as opposed to the card capacitor approach where new ROS bits can be created on site.

Figure 11 shows a closeup of the card. A ROS bit is represented by two locations along the word lines. There are two "word" line for each bit: one is the drive line to trigger reading. Attached to this line is one "pad" shaped per bit. There are two sense lines for each bit on the sensing plane that the ROS cards are pressed against: one for 1 and one for 0. The position of this bit pad over the two sense lines determines whether it is represents a 1 or 0. The other word line a "balance" line for attaching the complement of the bit flags. For example, compare the first two bits of the top two bit rows in Figure 11. The first two bit pads are the same: the right pad is attached to the drive line. The next bits are different: top row has left pad attached, and bext row has right pad attached.

(Much more about this particular ROS design can be found in S.A.Abbas,A Balanced capacitor Read-Only Storage, IBM Journal, July 1968.)

Mercury tubes were first used for delay lines; for example the UNIVAC I used mercury delay lines. A major improvement over mercury tubes was Magnetostrictive memory. The museum has a great example: it is the memory from an IBM 2848 control unit which fed video data to several IBM 2260 Display stations, the first video display terminals that IBM made (shipped in the mid-1960's)

Magnetostriction means that a material (a metal wire in our case) changes shape in the presence of a magnetic field. In our case, the wire expands or contracts , thus creating a mechanical pulse that propagates along the wire. Our wire was made of a special nickel-titanium-iron allow that had the right properties for propogating the mechanical impulse along the wire.

Figure 1 shows a memory module from the 2848 control unit. Each module held 11,520 bits, and there were up to four modules in a 2848 control unit, which could service eight 2260 terminals. A 2260 screen was 12 rows of 80 characters. Each character was represented by a six-bit code, so a 2260 needed 5,760 bits to refresh its display.

The memory worked by generating "bit" waves using a magnetic transducer at one end of the storage wire. Figure 3 shows the transducer and start of the wire, and Figure 4 shows the end of the wire, the sensor, and a fine-tuning adjustment. Figure 2 shows a close-up of the wire coils of wire, as well as the circuit board which used discrete germanium transistors. The access time for this memory was about several hundred microseconds, the time for a wave to travel along the complete wire. Both ends of the wire are dampened to prevent feedback of reflected waves.

Until the early '60s, most business applications were done on standalone card processing units (called by IBM unit record equipment by IBM) like the ones in our collection (shown following this topic). Even when computers started to be used, most programming was done on punched cards and all computers had punched card input and output. It wasn't until the middle seventies at IBM that we internally switched from card input to CRT terminals. Figure 1 is a box of 2000 fresh punched cards just waiting for our machines to use. (When I programmed on punch cards at IBM, our programs consisted of several trays of cards, each try containing several of these boxes.)

Standalone card equipment ranged from simple devices like keypunches to primitive computer devices like the IBM 602 Calculating Punch which could do multiplication and division. All but the simplest card equipment could be "programmed" by wiring a control board like the ones shown here (often called a plugboard). Other than the fairly rare calculating punches, the most advanced card devices were accounting (also called tabulating) machines like the IBM 407 which read cards and printed a report based on the card data using some counters and simple branching logic (as defined by the plugboard program). hese tabulating machines were the computers of their day and were pervasively used in business.

Accounting machines could also be used in non-obvious ways; in my first computer job in 1963 (application programming an IBM 7090 in Fortran and assembler), one of the scientists had programmed an IBM 407 to do matrix multiplication. (Here's a technical paper on this magic. Figure 2 shows a page describing the programming.) Later in college (1965-67) the computer we used (an IBM 1620) had only card input and card output. The output punched cards were hand carried from the computer to the 407 for listing. (The 407 was also used for many business tasks such as producing the student grade reports.) So, since every run I made ended up on the 407, I naturally learned how to program the 407 to do "cute", but useless things. We had lots of 407 boards, each preprogrammed with a particular application, similar to having multiple computer programs today.

Here is my collection of plugboards for IBM card equipment. Figure 3 is the board for an IBM 402 accounting machine, an earlier version of the 407, and Figure 4 show how the plugs come out of the other side. When the plugboard is inserted into the machine, the plugs contact sockets that are hardwired to card read brushes, card punch controls, and internal counters and other logic. Figure 4 also shows the label of what this program supposedly did (payroll). Figure 5 shows our four IBM 557 Alphabetic Interpreter plugboards. Since we actually have a 557 in the museum, having multiple boards allows us to have different programs ready to us. On the left side are some programming "statements" (plug wires) ready for more programming.

Figure 6 shows the plugboard for an IBM 088 Collator. Figure 7 shows the plugboard for an IBM 533 Card Read Punch. The 533 is particularly important as it was the input/output device for the IBM 650 computer, commonly considered to be the first mass produced computer. The 650 was the first computer I ever saw in person (on a high-school field trip to the engineering lab at UC, Berkeley), and it had a great influence on my later choice to specialize in computers.

Figure 9 shows the plugboard for an IBM 602 Calculating Punch. Figure 8 is a closeup of this board showing some of the controls for multiplying and dividing. Figure 10 shows our three plugboards for our IBM 514 Reproducing Punch. (Also shown are some programming plugs; these can be used on all the IBM boards.) Figure 12 show the control board for a rare device: the IBM 063 Card-Controlled Tape Punch. This device read cards and punched the corresponding values in paper tape.

Finally, Figure 11 shows a particularly rare piece: the control plugboard for an IBM 6400 Accounting Machine. This device is little know and I've never seen one (as opposed to all the other devices discussed in this section).

Much more information about IBM keypunches, histoy, how they work, codes, and so forth, is found here.

Figure 1 shows our IBM 026 Keypunch. The 026 was first introduced in 1949 replacing even older keypunch models. Figure 2 shows our more modern IBM 029 Keypunch. The 029 was first introduced in 1964 and was the last version IBM made.

An example application of the 557 is printing payroll checks on card stock. Another of IBM's card machines (or even a computer) would punch the information on cards, which would then be run through a 557 to print the readable information such as recipient and amount.

The IBM 2870 was the multiplexor control unit for the System/360 family. Figure 1 is the control panel from an 2870 controller. (The wooden frame is an add-on for displaying the panel.) Figure 2 is a page from the 2870 manual showing this control panel. Careful study of the control and status indicators shows that the 2870 was effectively a programmable computer.