1. The Last EAM Machine

When I returned to civilian life in the fall of 1955, I immediately continued my education at a prestigious west-cost university. One of the items of discussion at that time was the impending computer revolution. Some people discounted it saying that two or three computers could do all the computing that the world would ever need, and no one predicted the real revolution that occurred.

Before IBM put out its first computer there was a machine that formed a link between an accounting machine and a computer. It was called the CPC or Card Programmed Calculator. These were accounting machines with an extra card reader attached. Programming language statements were punched into punch cards. These cards were placed into the card reader and, as they were read, the program was executed.

There were two types of cards: (1) a statement card, and (2) a decision card. Each card contained two command fields called a primary command and an alternate command. An example of a command was: "replace "C" with "A" plus "B". A decision card contained a statement that would evaluate to "True" or "False". If true, the subsequent commands would be taken from the primary command field on the subsequent cards. If false, the subsequent commands would follow the alternate command sequence.

One of the command fields could contain a null command.

As the program ran, the operator would take the cards, after each had been read, from the out-hopper and place them into the in-hopper. Thus this card driven program would run until all the data was processed, or until the operator dropped the card deck. Most of the time the alternate path was a different length than the primary path, so one of the paths had to padded with null commands.

People were not complete idiots in those days. A very early convention reserved eight columns on each card for identification and sequence numbering of cards. No one was ever burned more than once by a dropped deck of unsequenced program cards. The use of Columns 72 through 80 of a punch card for identification was an early convention. I do have vague recollections of the use of Columns 1 through 8, in the very early days.

2. The Biquinary Machine

I never used the CPC because of a new "real" computer replaced it before I got to the lab. It was called the IBM 650. Figure 1 is a picture of this machine. It had vacuum tubes and 2000 words, each word was made up of a sign plus ten decimal digits. I do mean decimal digits. There was no binary arithmetic in this machine. The memory was a magnetic drum. There was true sharing of memory by program and data.

Figure 1-- The IBM 650

Not shown in the picture of the IBM 650, above, was a line printer that accepted card input. There was no way to read your output unless you had a printer to print the data contained on the output cards.

The registers and memory of the machine used seven bits to represent one decimal digit. For each digit, there was a set of five bits, {x=0,1,2,3,4} and a set of two bits, {y=0,5}. Each valid digit had exactly two bit in the "on" position, one bit from each of the two sets. For example: a three was represented by the 3 bit from the first set and the 0 bit from the second set. An eight was the 3 bit from the first set and the 5 bit from the second set. Mathematically, the decimal numbers 0 through 9 were represented by the ordered pair (x,y), where 0 was (0,0), 2 was (2,0) and 8 was (3,5). Arithmetic for these sets was called biquinary arithmetic, and hence this machine was called a biquinary machine. In addition, each word of memory had a sign bit.

Figure 2 -- The IBM 650 Console

Figure 2 shows the IBM 650 console. Note the input dials and the biquinary display.

Each arithmetic instruction contained a two digit operation code and two four digit addresses. The second address of each operation was the location of the subsequent instruction. You could speed up your program execution by strategically determining into which memory locations you used for your data and program steps. This was because the memory was a spinning drum with about 40 locations under the read heads at any given time. You would determine how long an instruction took to execute and place your next instruction in a memory location that would be under a read head as soon as the prior instruction was executed. The manual for the machine contained time tables for instruction execution, the measure of time being the number of memory locations that passed each read head.

Decision instructions contained a two digit operation code that evaluated a positive/negative situation, or a zero/non-zero situation, branched accordingly.

3. Input to The Biquinary Machine

The input to this computer was punched cards. A read instruction would allow you to read data into ten or less sequential locations on the drum. Note that each location had ten digits and a punched card had only 80 columns. So you had your choice of putting ten digits of information into each of eight memory locations or eight digits of information into each of ten memory locations. But there was only one read command. So how was this choice made?

We had to insert a plug board into the card reader!! We had two plug boards one for each input configuration. One board plugged data into ten memory locations, and another board plugged data into eight memory locations. In either case we lost the last word of memory if we used eight columns for card identification and sequencing.

A sign could occupy the same punch card column as a digit. My recollection is that the sign was punched in the same column as the least significant digit of each data word. Naturally, the location of the sign had to be wired into the plug board.

4. Running a Program

You didn't have a screen full of icons, and you didn't have a mouse in those days. You didn't even have an operating system. So how did you start a program?

On the picture of the console, figure 2, you can see the ten 10-position dials on which you could set to represent either a command or data. To the right is a 2-position dial to set the sign. Below the set of ten dials was a set of four 10-position dials that allowed you to set in a memory location. You could read out this memory location on the biquinary display.

The machine was about the size of an ATM machine. To start the machine you would use the set of ten dials into which you could set one machine instruction. Pressing a button on the console caused the instruction dialed to be executed. You normally started the machine by entering a read instruction into the ten dials. This instruction would read one punched card into locations, say, 100 through 107 and take the next instruction from location 100. This was the first bootstrap program. The first card in your deck was the bootstrap card. This card was followed by several other cards that contained the program loader, which was subsequently followed by your program.

If you already had a program in your machine you could set the dials to no-operation as the operation code and the address of the first instruction in the program as the second instruction address. This, of course, was equivalent to a go-to instruction.

Your ten digit console memory had an address that I believe was memory location 8000.

Interactive programming consisted of setting the dials to a signed ten digit decimal number that could represent either data or a program step. At some point in your program you could use the data in Location 8000, or use Location 8000 as the next instruction.

5. Output from The Biquinary Machine

The only output device was punched cards. The early models of the IBM 650 did not have alphabetics, so all the output was numbers. You always had a card printer near your IBM 650. Your cards normally went right from the hopper to the printer where your data was printed.

You usually threw your cards away after printing your output. This made scrap card elimination rank with the scrap paper elimination problems we sometimes have, today.

Initially old 407 accounting machines were kept out of the scrap heap and put into service as printers. This whole process ran at about 100 cards per minute. This normally wasn't a problem because the IBM 650 didn't compute fast enough to punch cards at full speed.

6. Floating Point Arithmetic

Although each memory location contained a signed ten decimal digit number, there were no decimal points, no alphabetics, and no special characters. But we still had floating point arithmetic. A convention was adopted for displaying floating pointing numbers. It was called the Plus 50 convention. For example, the floating point number that represented the value 1, 1.0000000 E 00, was written as 5010000000. The value 0 .1, that we now represent as 1.0000000 E-01, was written as 4910000000. Within each word in the computer memory, the sign bit was used to indicate a negative number. For example the value -0.0125 (-1.25000000 E-02) was written as -4812500000.

Strangely, we accepted this cumbersome notation and used it for several years. What was even stranger was that it existed longer than it had to exist. I remember seeing output data from the computers in the IBM 700 series that used this notation. The 700 series computers did have the capability to output upper case alphabetics, periods, and special characters.

7. Assemblers and Compilers

A symbolic assembler was developed for the IBM 650, but many of the purists (including myself) preferred to write in machine language and do rough optimization as we wrote. Note that we would program into actual memory locations. The concept of a relocatable program was not around.

The assembler for this machine was called the Symbolic Optimal Assembler Program (SOAP). It could map labels into memory locations and convert mnemonic operation codes. Also, it would do a rough program optimization to minimize access times to the rotating drum.

Although a FORTRAN-like language, called FORTRANSIT, was developed for the machine, most of the higher level language programming that I encountered was done in the "three address language" developed by the Bell System. This is a language form that I have always called the quadruple language, and I have used variations of the language as an intermediate language in compiler development. Each statement was made up of an operation and three addresses, the third being the destination address. For example, the statement:

Add A B C

meant to add the content of Memory Location A to the content of Memory Location B and place this value in Memory Location C.

I found it very surprising when I first encountered programmers programming in the three address language. They did not know the machine language of the machine or how to operate the machine. These were the first people who specialized in being programmers but not computer operators. There were other people who ran these programmers' programs by stuffing cards into hoppers and turning dials and pushing buttons by rote.

When I ran my programs on the IBM 650 I was both the programmer and the operator. I thought everyone who programmed the computer knew how to operate it, and knew everything about every piece of code in the machine. I believe that the IBM 650 was intended to be programmed and run by a single person. That certainly is not the case with the computers of today.

The FORTRAN-like compiler for the IBM 650, FORTRANSIT, came out after, in 1957, FORTRAN came out for the IBM 704. Consequently, I do not believe FORTRANSIT was available during the time frame that I used an IBM 650.

8. Epilogue

What I describe, above, was typical of the computer environment in 1956 and 1957. The IBM 650's that I used were some of the first produced. In early 1958, I moved on to the next generation of computers, the 700 series. The IBM 650's existed for several additional years, and improvements and additional capabilities were added.