Computing History Displays: First Floor - The IBM 1620

This IBM 1620 on display, which arrived in 1963, was the first computer at The University of Auckland.

The IBM 1620 was a popular computer at universities worldwide, particularly for science and engineering calculations. In New Zealand universities the first digital computer, another 1620, was installed at The University of Canterbury earlier in 1963. Massey University also installed a more-advanced version that was used for university records and accounts until 1974. In the following picture Canterbury University students celebrate the arrival of their computer in their annual procession in 1963 (to translate the joke: Mr Bruce Moon (later to publish the first book on programming in New Zealand) was the director of the computer centre and there is a pun on ICBM as Intercontinental Ballistic Missile at the time the US had announced plans to send a man to the moon - photo courtesy of Mr Moon.)

Both Auckland and Canterbury's computers were later purchased by Mr Ron Dent who ran a data processing service from West Auckland well into the 1980s and kindly donated this machine back to the University of Auckland.

The designers of the 1620 put a great effort into making the computer affordable. As a result the 1620 was purchased for the modest sum of about 50,000 NZ pounds. Allowing for an inflation factor of about 20, this corresponds to over a million dollars in today's money. The modern PC, fully equipped, costs less than $3000, so the 1620 was about 500-1000 times more expensive!

As well as reducing cost, the simplified design resulted in a computer that was fairly slow. At top speed our 1620 could perhaps add 1000 pairs of numbers per second - this is over 1000 times faster than using a mechanical calculator which is why the 1620 was so useful. However, a modern PC could do a billion such additions in the same time - the PC is over a million times more powerful than our 1620!

Putting all this together, how much better is the modern PC than the 1620? If you divide the speed and cost advantages, that comes to a million times a thousand or about a billion times better. That's progress in the computer business! (Do note, to be fair, that there were other much more powerful computers available in the 1620's era.)

Being the only computer in the University our 1620 was in very high demand and was operated 24 hours per day, 7 days per week. Many of the users of the computer were graduate students who would have to book time to run their programs in the dead hours of the morning from 2am to 6am. They could amuse themselves by watching the flashing lights on the 1620's main panel. At that time this "fractured-German" sign appeared on many computer room walls.

The one way that the 1620 is similar to the PCs of today is that it was operated by the programmers themselves. The details of using the computer were very different from today and very cumbersome. Here are some of the steps involved:

• The user would prepare programs on coding sheets and have them punched on cards.
• To run a program, the compiler deck of cards had to be retrieved from its storage cabinet and loaded - read from the card reader into the computer's memory.
• The user's program written in Fortran would then be read from the card reader and a machine language program produced by the card punch.
• The user's machine language program would then be loaded and it would in turn read the user's deck of data cards.
• The user's program would punch its results on cards which the user would take to a keypunch with typewriter attached that would print out the information punched on the cards.

This was a very long and slow process (and was even longer with the 2-pass Fortran II compiler) with many opportunities for making mistakes such as loading the wrong cards or dropping a card deck. See here the instructions for dealing with a card-jam alone! It was a very frustrating process but the results were worth the effort and many PhD theses were built around the 1620's calculations before it was replaced in 1968.

After the 1620 was replaced by more powerful computers the programmers were kept away from the computers which were tended by professional computer operators. The programmer would submit a tray of punched cards containing program and data and would receive back (hopefully quickly, but often not) the deck along with a line-flow printout showing how the program was compiled and executed. One mistake in punching a card would mean no useful output and another wait of many hours for the corrected program to be run - a very slow process indeed.

Electronic technology in the early 1960s was very expensive and cumbersome. Electronic circuits were designed from separate components - transistors, resistors, and capacitors - each packaged separately. These basic components were then mounted on small boards that performed some simple common function such as a logic gate or a "flip/flop" for remembering one bit. The circuit boards connected the components with wiring constructed by a process related to printing. Each board had connections arranged on one edge for signals into and out of the board. A design goal was to minimise number of distinct types of boards as this simplified manufacturing and maintenance. Boards had wiring "printed" on both sides - in the image alongside of a typical circuit board, John Pratt has "removed" the board to show the connections.

Boards were plugged in to a "back plane" that provided a separate pin for each I/O connector on the circuit boards. Connections between pins were made with insulated copper wires. Good conduction was assured by wrapping the wire tightly around the pins at each end of the connection. The wiring was performed automatically by a special machine that received its instructions from a deck of punched cards.

The 1620 used magnetic core memory. The 1620 processor used 2nd generation core, but the card reader, which could save the contents of an entire card, used older 1st generation technology from the late '50s. The smallest 1620 configuration had a memory that could hold 20,000 digits, near enough to 20Kbytes in today's terms! The memory access time in 1620 was initially 20 microseconds though this was later improved to 10 microseconds.

The 1620 represents a watershed in the history of computing. When it was being designed, the prevailing thinking was that its programs would be written in the computer's machine language or assembly language. But what really happened with the 1620, and all succeeding commercial computers, was that most of the programming was done in high-level programming languages such as Fortran.

Because the designers thought that users would be working in machine language they attempted to make life easier by making the computer operate with our familiar decimal numbers rather than binary numbers. Although the memory held decimal numbers, and the address of a memory location was a decimal number, the decimal digits were themselves represented in binary. So, the control panel, which displayed memory addresses and their contents with off/on lights, shows the Memory Address Register (MAR) as a 4-digit number, each digit being represented by bits 8, 4, 2 and 1 - what is called BCD for Binary Coded Decimal.

Each memory location of the 1620 contained one decimal digit. It actually represented the digit with 6 bits. In addition to the BCD code there was a special "flag" bit that indicated something special about the digit. The final bit was a parity bit that was used to detect errors in each digit that was stored.

Instructions in the 1620 memory were a sequence of up to 12 digits. Most instructions had a two-digit operation code and two five-bit operand addresses, though some were shorter. A typical instruction would be to take the number at the first operand, add it to the number at the second operand and store the result at the first operand's location. This is called a memory-to-memory instruction set.

Decimal numbers in the 1620 memory could be as small as 2 digits but there was no upper limit on number length. The address of a number in memory was that of the low-order end stored at the highest address. The number ran down in memory locations until it reached a digit that had the flag bit set, indicating the end of the number. The flag bit of the low-order digit was used to represent the sign of the number. The use of signed magnitude numbers is very rare nowadays but in a slow machine like the 1620 having the sign at the low-order end was very important because the hardware could immediately know if an addition was really a subtraction.

Although its price seems high to us today, great effort went into simplifying hardware to reduce costs. The hardware was absolutely minimised. The first 1620 couldn't even add - to find the sum of, say 3 and 4 it would look in memory location 234 and hopefully find that it had been loaded with 7. A nickname given to the 1620 was CADET for "Can't add, doesn't even try" but later versions did have an adder capable of adding two digits (though multiplication was still performed by table look-up.)

IBM 1620 back plane

Each circuit board plugs in to a back plane. Copper wires make the connections between circuits on different boards, the junction between wire and plug being made by a machine that wraps the wire tightly around the plug post. This back plane is from the IBM 1620 at Massey University. It was rescued from the Massey 1620 "demolition party" and donated to our collection by Peter Gibbons.

IBM 1622

The IBM 1622 card reader/punch on display would read an entire 80-column card and store the data in its own memory. It provided the bit patterns on the card to the 1620 CPU when requested. It could also buffer 80 columns of data to be punched.

IBM 526

The IBM 526 on display was a card punch with an attached typewriter that was used to list off-line the decks of punched- cards output from the 1620 and from the University's tabulating machine.

IBM 1620 Manuals

We have made available for inspection some of the original manuals and brochures for the 1620. These include some of the engineering circuit diagrams that IBM technicians used to trace faults in the machine.