The IBM 650 Magnetic Drum Data Processing Machine was announced 2 July 1953 (as the "Magnetic Drum Calculator", or MDC), but not delivered until December 1954 (same time as the NORC). Principal designer: Frank Hamilton, who had also designed ASCC and SSEC. Two IBM 650s were installed at IBM Watson Scientific Computing Laboratory at Columbia University, 612 West 116th Street, beginning in August 1955.
IBM sometimes refers to the 650 as its first computer, although it is predated by at least ASCC (1943) and SSEC (1947), which were not products, and the 701 (1952), which definitely was. Perhaps it is more accurate to call it IBM's first commercial business computer (since the 701 was intended for scientific use), and the first computer to make a meaningful profit. In any case, the IBM 650 was the first general-purpose computer to be installed and used at Columbia University (the NORC was built here in 1950-54, but the only Columbians who were able to use it were a couple Watson Lab insiders [61,65]). As noted in the timeline, the Watson Lab 650s supported more than 200 Columbia research projects, and were also used in a series of intensive courses on computing. Unfortunately I have not been able to locate photos of the Watson Lab machines.
The Basic 650 Configuration.
Photo: IBM Archive
|Left to right:|
Type 650 Power Supply
Type 650 Console Unit
Type 533 Read-Punch Unit
The 650 is a vacuum-tube logic, drum-memory, decimal — not binary — computer. Data is stored in words containing ten decimal digits and a sign, and instructions operate on numbers stored in this format. IBM called the 650 an automatic calculator, not a computer:
One of the most exciting achievements of our generation is the development of the electronic automatic digital calculator. Although any schoolboy can perform any operation done by the calculator, the speed and economy with which the calculator does them are so great that automatic calculation is revolutioninzing large areas of science, engineering, business, industry, and defense. A single giant calculator can do more arithmetic than the entire population of the United States could do with pencil and paper .
Until the mid-to-late 1950s, the word "computer" referred to people who performed computations, not to machines . But before the decade was out, "digital computer" applied to the 650 and other "giant brains" and a "calculator" was the clunky thing on your desk.
Originally a cards-only machine, the 650 was compatible with IBM's popular line of unit record equipment (sorters, collators, punches, accounting machines, etc), but advances first seen in the 700 series were retrofitted to it over the years: magnetic tape drives, line printers; IBM 407 interconnect, RAMAC disk drive, core memory. Here's a 1955 configuration, as shown in the IBM Type 650 Manual of Additional Features:
Left to right: four Type 727 Magnetic Tape Units, a Type 652 Control Unit, Type 407 Accounting Machine (foreground), Type 653 Auxilliary Unit (high-speed storage, back), Type 650 Console Unit (foreground), Type 655 Power Unit (back), and a Type 533 Read-Punch Unit. CLICK IMAGE to magnify.
The 650 was a true general-purpose computer, the natural evolution of the CPC (Card Programmed Calculator) to a stored-program computer with a full set of decimal arithmetic, logical, and control instructions, plus (later) the ability to handle alphabetic data. It was initially programmed in machine language, then in SOAP (Symbolic Optimal Assembly Program), its native optimizing assembler (if "optimizing assembler" strikes you as an oxymoron, keep reading). SOAP was written in 1955 at Watson Lab by Stan Poley ; it was not the first assembler, but it was close (credit for that usually goes to Nat Rochester's assembler for the IBM 701 in 1954).
By 1957 a FORTRAN compiler (FORTRANSIT) was available (which compiled FORTRAN into SOAP; a native FORTRAN compiler appeared in 1959). (You will recall that FORTRAN itself was the child of Columbia University and Watson Lab alumnus John Backus.) Other languages used on the 650 included ADES II, BACAIC, BALITAC, BELL, CASE SOAP III, COMTRAN, DRUCO I, DYANA, EASE II, ELI, ESCAPE, FAST, FLAIR, GAT, IPL, IT (Internal Translator), KISS, Bell Labs L1 and L2, MAC, MITILAC, MYSTIC, OMNICODE, RELATIVE, RUNCIBLE (see References below), FORTRUNCIBLE (a cross of FORTRAN and RUNCIBLE), SIR, Speedcoding, SPIT, SPUR.
Here's an illustration from the 1958 section of the timeline of what it means to be a cards-only machine:
Although FORTRAN — the first high-level, machine-independent programming language — marked a great leap forward in user friendliness, and was probably available for the 650 by this time, it's worth remembering how one ran a FORTRAN job in the early days. First you punched your FORTRAN program on a key punch machine, along with any data and control cards. But since the 650 had no disk, the FORTRAN compiler was not resident. So to compile your program, you fed the FORTRAN compiler deck into the card reader, followed by your FORTRAN source program as data. After some time, the machine would punch the resulting object deck. Then you fed the FORTRAN run-time library object deck and your program's object deck into the card reader, followed by any data cards for your program. Your program would run and results would be punched onto yet another deck of cards. To see the results, you would feed the result deck into another machine, such as an IBM 407, to have it printed on paper (if the computer itself had no printer, as original 650s did not).
The 650 had a single 10-digit accumulator (called "Upper") for addition and subtraction, with a 10-digit extension ("Lower") for multiplication, division, and shifting, plus a 10-digit Distributor (essentially, another accumulator), and 1000, 2000, or 4000 10-digit words of drum memory. Instructions were a sequence of ten digits: a 2-digit opcode, a 4-digit operand address, and the 4-digit address of the next instruction to execute.
Here's a sampling of the instruction set. Symbolic opcodes and other information are from Reference  below; different mnemonics are used by different assemblers (e.g. in SOAP II all mnemonics are three letters).
Mnemonic Value Function Msec AU 10 Add Upper 0.4 RAU 60 Reset Add Upper 0.4 SU 11 Subtract Upper 0.4 RSU 61 Reset Subtract Upper 0.4 STU 21 Store Upper 0.4 MPY 19 Multiply 10.0 DIV 14 Divide 15.0 DIVR 64 Reset Divide 15.0 BRNZ 45 Branch on Nonzero 0.4 BR- 46 Branch on Minus 0.4 BROV 47 Branch on Overflow 0.4 SHRT 30 Shift Right 2.5 SHRD 31 Shift Round 2.5 SHLT 35 Shift Left 2.5 TLU 84 Table Lookup SPOP 69 Special Operation RD 70 Read Card PCH 71 Punch Card STOP 01 Stop "Reset Add" means to clear the accumulator and then add the contents of the memory address to it. Thus one instruction handles both "load" and "add". SPOP is used for library calls (e.g. when the sine or natural logarithm function is loaded at a known address) or block transfers. Most of the "Upper" instructions have "Lower" partners (AU/AL, SU/SL, etc), and some also reference the Distributor. Each instruction contains an explicit GOTO address, indicating the next instruction to be executed. Interrupting the flow of control is accomplished with the Branch instructions. Such things as double-precision or complex-number arithmetic are handled by subroutines. Floating-point arithmetic could be done by optional floating-point hardware or by subroutine. Believe it or not, that's all it takes to write programs to do mathematical calculations of any kind on a dedicated computer.
Operating System? What Operating System?
The reason each instruction included a GOTO has to do with the 650's rotating drum memory. In computers with solid state memory, instructions are naturally stored and executed in sequence — after each non-Branch instruction the program counter is automatically incremented to the address of the next one. But when the program is stored on a drum, where is the next instruction? By the time the current instruction is finished executing, the next one has rotated out of reach, and we'd have to wait for it to come back under the read head to fetch it. Thus 650 programming was not just a matter of algorithm and numerical analysis, but also of optimizing the arrangement of instructions to prevent drum latency from slowing the program down. The table above shows execution times for each instruction. The drum cycles at 12,500 RPM. The programmer figures out where the drum will be when the current instruction finishes executing, and puts the next instruction at that spot on the drum. Or better yet, SOAP, the Symbolic Optimal Assembly Program, picks the location for you automatically if you leave it blank.
Peter Capek, a user of the Columbia 650s, now at IBM, recalls, "The reason the machine had core memory is interesting... it wasn't just because it was nice, or for performance. It was needed as a buffer between the drum and tapes, which transferred at different rates. So you had to explicitly read/write into core and then transfer to the device. You could put a program into core memory and avoid the problem with waiting for the drum to spin, but since it was only 60 words, there wasn't much you could do with it."
Over the years, instructions were added until, as Jim Thomas of the University of Hawaii points out, "by the end of its life it used close to the available 100 possibilities (what with tape, the core memory as you describe it, the 407, etc.)"
IBM expected to deploy only about 50 of these systems, but the demand surprised them. The 650 was relatively cheap, carried a hefty academic discount, was compatible with existing card equipment, it would fit in one room, and it was "user friendly" — decimal arithmetic, small instruction set, handy console. It was one of the first computers that could be used "hands on" by programmers (CLICK HERE to see a 1958 photo of Don Knuth at the 650 console) (or if that one has disappeared do a Google search). In all, 2000 were installed in the nine years of manufacture (1953-62), surpassing the entire combined sales of all the 700 series. Support for the 650 was withdrawn by IBM in 1969. The 650 had a followon, the IBM 7070 (1959), architecturally similar but with transistors instead of tubes and cores instead of a drum, and which came with not only card reader and punch, but also typewriter console, and (optionally) disk and tape drives, line printers, etc. It seems to have been popular in Italy — "Il primo sistema elettronico completamente transistorizzato".
In August 2015, Gerardo Cacciari sent the following response to the above (and also corrected some spelling errors). The incorrect reference (and spelling) came from this page (in Italy and in Italian); I should have cited it. As to being the first transistorized computer, Gerardo is right; the 650 was IBM's first transistorized computer (according to IBM).
The curious thing is that that claim (i.e. the IBM 7070 being the first fully transistorized computer) is not entirely true or at least should be shared with other manufacturers. Being Italian, I'm most fond of the Olivetti Elea 9003, which was quite advanced for its time. It could run up to three concurrent programs (it was "partitioned"), had the concept of interrupt, and was very fast. It was announced in 1955 and the first production machine shipped in 1960 to a big textile factory. The second one shipped to a major bank and when was retired (in the seventies!) it was donated to a techical school which kept it running for educational purposes. Today it is the only surviving Elea 9003 in running condition after more than fifty years.
The following are photos I personally took when I visited it some years ago:
These are photos a friend of mine took the same day:
This explains quite well how it worked:
And these are for reference:
The Watson Lab 650s remained in operation until... when? They were definitely running in 1962 (where they are mentioned in university publications), and definitely gone by 1970, when IBM left the building.
From the website of John H. Clark, http://www.users.nwark.com/~rcmahq/jclark/, with [corrections] from Jim Thomas:
"The CPU was 5ft by 3ft by 6ft and weighed 1966 lbs, and rented for $3200 per month. The power unit was 5x3x6 and weighed 2972 pounds. The card reader/punch weighed 1295 pounds and rented for $550/month. The 650 could add or subtract in 1.63 milliseconds, multiply in 12.96 msec, and divide in 16.90 ms. The memory was a rotating magnetic drum with 2000 word (10 digits and sign) capacity and random access time of 2.496 ms. For an additional $1,500/month you could add magnetic core memory of 60 words with access time of .096ms.
"One neat feature about an IBM 650 program was the use of [two] addresses; the [second for the next] instruction. This means you could drop your deck and as long as you got the first card in front your program would run. [Although the 650 has 2-address instructions, an assembly language card contains a third address: the address of the instruction itself.]
"While the IBM 650 was not a super-hot machine, it did have one feature that made it sell: lots of blinking lights. With that anyone could tell something was going on. Some authors attribute the success of IBM to these blinking lights and the fact the computer used the same cards as the other unit record equipment of IBM. Actually the output of your 650 program was punched on cards and you would take the deck over to a 402 Accounting Machine to get a print out."
CLICK ON THE IMAGE for a closeup and description of the IBM 650 control console.
Click on images to magnify:
Type 533 Read-Punch
Photos: IBM 650 Manual (see References below).
There are a few things I can add for the 1958-1968 period at Watson, etc.:
Patch-boards (for non-one-to-one 511 and 403 formats) were always scarce and expensive. Folks would hide them in the darnest places, like inside the 650's power cabinet. In 1959, I was hunting for ham parts on "Radio Row" — now the site of the WTC [this was written in May 2001]. I found and bought four boards for the 403 printer, for a total of $10! Each was stuffed with patch wires, which the store considered a pain. Their parentage was uncertain, but they were in perfect condition. I kept one, removed the cords from the others. I then gave the three other boards to friends, thus acquiring a life-time of chits.. I "Dremeled" my name on mine and still have it; it's here, someplace...
Of course, after Fortransit, IT, and SOAP translations were complete and punched-out on numeric-only decks, any 650 could run the programs.
In 1958, Tom Guttman wrote a hand-written warning on a 3x5 file card and taped it at the top of Watson's "upstairs" IBM_650. It remained there for years, until the machine was disassembled and removed. This is not 100% correct, although it's very close. Tom's cautionary sign — which he'd copied from a similar one taped to the 650 in IBM's White Plains "Service Bureau" — will be familiar, even in our current and non-blinking-light times...:
Achtung! Alles Lookenspeepers !
Das computermachine ist nicht fur gefingerpoken und mittengrabben.
Ist easy schnappen der springenwerk, blowenfusen, und poppencorken mit spitzensparken.
Ist nicht fur gewerken bei das dumpkopfen.
Das rubbernecken sichtseeren keepen hans in das pockets muss...:
Relaxen und watch das blinkenlichten.
Also in this building was the Columbia-Princeton Electronic Music Center.
For a few years, while a student, I worked there, while it was cooperatively run by the of "early greats" of the field, namely Vladimir Ussachevsky, Otto Luening, and Milton Babbitt. I'd already had considerable experience in recording studios, ham radio, and WKCR, so I made myself useful maintaining their (vacuum_tube only) facility. All 3 were true gentlemen, but "characters" and sometimes quite zany... While working for them, I came to know folks at ERL much better, though I'd first met several of them a few years earlier, during my HS "Science Honors" days... This is how I came to work at ERL.
Working for John Bose, I often wrote and ran programs on "their" 650. Bose was a strong and constant force to get more computing power on campus. Interestingly, Bose was also a strong believer in _analog_ computers, which used lots of op-amps ( = operational amplifiers) and patch cords. I also programmed and ran their two analog computers, now a totally lost art, but not the subject of Frank's history! [Only because I haven't been able to locate any information.]
Incidentally, Professor Bose, who had appointments both in EE and at ERL, had been a doctoral student of perhaps Columbia's most famous EE professor, Major Edwin H. Armstrong! EHA invented FM, the super-heterodyne receiver, and the super-regenerative amplifying detector. A pretty good lifetime accomplishment for this CU grad!
I worked in 612 West 116th Street, in the sub-basement the summer of 1954 for IBM, for Erwin Hahn, who left for the University of California at Berkeley (in 1953 I worked in Pupin for Gardner Tucker, and was paid less than the guys. Erwin Hahn saw to it that I was paid the same). He was investigating the "spin echo" effect, which led to MRI's. He could also play Yankee Doodle by knocking on his head and changing his face and mouth. IBM got upset since he wouldn't work 9 to 5 although he put in many more hours. They had a time-card device and figured the time in hundredth of an hour (More about the time clock HERE and HERE) It was called the Watson Lab at that time. But there were many IBM labs, all called Watson as I recall.
I also did my original programming, while a graduate student, for the IBM 650. I wrote a small program after the Watson Lab Short Course for the 650, which I took around 1960, but someone else entered it into the computer. Only Marian Hamann Biavati and I, the only women in the course, got it right the first time.
Thanks to Diarmuid Pigott for corrections to the list of IBM 650 programming languages.
Most recent update: Sun Aug 30 19:34:18 2015