Columbia University Computing History

The IBM 650 Magnetic Drum Calculator

Photo
Photo: U.S. Army Anniston Ordnance Depot, from BRL Report 1115, 1961 (see Links below)

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.


Photo
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 [64].

Until the mid-to-late 1950s, the word "computer" referred to people who performed computations, not to machines [57]. 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 [65]; 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 [1] 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 systema elletronica completamente transistorizzato".

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.


Type 533 Card Reader and Punch.

Click on images to magnify:

Type 533 Read-Punch

Card Feeds

Control Panel

Photos: IBM 650 Manual (see References below).


From Mike Radow, formerly of Watson Lab:

There are a few things I can add for the 1958-1968 period at Watson, etc.:

  1. Watson "north", 612 West 116th Street, had two IBM 650s, which I frequently used. Each had a 511 card reader and a 403 printer.

    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...

  2. Only the "upstairs" (non-basement) machine could be used to create SOAP_decks, since the "downstairs" machine did not have the "Alpha" feature. This option was required to read non-numeric (multi-punched) card columns. Strict policing largely restricted this machine to compiling-before-"running", since the "Alpha" feature was a critical resource. Macho-types avoided the bottleneck by writing directly in machine code. This was very tricky, since the 650 was a 3-address, decimal machines, with all memory on a rotating drum. In order to get any kind of efficiency, programs had to be optimized for the (different) execution times of the various op-codes. SOAP, the Symbolic Optimum Assembly Program did this, although better "hand-optimization" was possible by the (very) patient. Incidentally, a copy of SOAP was used to optimize itself!

    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.

  3. There was also a 650 in the "Sheffield Dairy" building, on 125th Street [Prentis Hall]. It was largely used by ERL (= Electronic Research Labs), which — after the 1968 riots — left Columbia and continued its secret military research as RRL (= Riverside Research Labs).

    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!


In August 2005, as we approach the 50th anniversary of the installation of the 650 in Watson Lab, Melissa Metz of AcIS revealed that her mom, Claire, a physicist, had been at Watson Lab at the time; she recalls:

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.


References:

  1. Type 650 Magnetic Drum Data-Processing Machine - Manual of Operation, first revision, Form 22-6060-1, IBM, 590 Madison Avenue, New York 22, NY (June 1955). (Also the first edition, Form 22-6060-0, 1953).
  2. Type 650 Magnetic Drum Data-Processing Machine - Manual of Additional Features, Form 22-6265-1, IBM, 590 Madison Avenue, New York 22, NY (1955).
  3. Mace, David, and Joyce Alsop, A Simplified System for the Use of an Automatic Calculator, Watson Scientific Computing Laboratory, Columbia University / IBM (1957), 75 pages (COVER).
  4. Baker, C.L., and Grace Murray Hopper, "Anecdotes: Stories from the HOPL Banquet: Dear John; Meeting JOSS; The First Bug; SOAP Assembler; Debugging ..., IEEE Annals of the History of Computing Vol.3 No.3 (July-September 1981), pp 283-286.
  5. Jeenel, Joachim, Programming For Digital Computers, McGraw-Hill (1959), 517 pages. This book came out of Jeenel's Watson Lab 650-based courses at Columbia, and was an expansion of the Mace/Alsop book (to which Jeenel was also a contributor). This book never once mentions the 650 or any other kind of computer, but clearly has the 650 in mind (using much of the same terminology, e.g. "reset add" for loading a word from memory to an accumulator, and assuming a two-address instruction format).
  6. Andree, Richard V., Programming the IBM 650 Magnetic Drum Computer and Data-Processing Machine, Henry Holt and Co., New York (1958).
  7. Bashe, Charles J.; Lyle R. Johnson; John H. Palmer; Emerson W. Pugh, IBM's Early Computers, MIT Press (1985): pp.165-172 (design); 351-353 (SOAP).
  8. Grosch, Herbert R.J., Computer: Bit Slices from a Life, Third Millenium Books, Novato CA (1991), ISBN 0-88733-085 [see Chapter 13 and elsewhere (search for "650" and "Hamilton")].
  9. IEEE Annals of the History of Computing, Volume 8, Number 1, January 1986. Special IBM 650 issue.
  10. Knuth, Donald, RUNCIBLE-Algebraic Translation on a Limited Computer, CACM, V2 #11, Nov 1959, pp.18-21. RUNCIBLE stands for Revised Unified New Compiler with IT Basic Language Extended. IT (Internal Translator) was developed at Case Institute of Technology (CIT, now Case Western Reserve University) by Perlis, et al, about 1957 for the Burroughs 205, then adapted to the 650. On a random web page I found a 2001 discussion of the word runcible stating that this article was Knuth's second publication -- "his first was in Mad Magazine (1957), on a system of weights and measures he designed. According to one of Knuth's students, Mad 'inexplicably declined' his second article, on Runcible". Also see Links, just below.
  11. Hamilton, F.E., and E.C. Kubie, "The IBM Magnetic Drum Calculator Type 650", Journal of the Association for Computing Machinery, Vol.1 No.1 (Jan 1954), pp.13-20 (also published by IBM, 9 Sep 1953).
  12. Horner, John T., "Relative Programming for the IBM Type 650", IBM Technical Newsletter, No.10, IBM, New York (Oct 1955), pp.15-27.
  13. Poley, Stanley, and Grace L. Mitchell, SOAP, IBM 650 Symbolic Optimal Assembly Program, IBM, Endicott NY (20 Nov 1955), 28pp.
  14. Ruterauff, R.E. "Symbolic Coding and Assembly for the IBM Type 650", IBM Technical Newsletter, No.10, IBM, New York (Oct 1955), pp.5-14.
  15. Sweeney, Dura W., and George R. Trimble, Jr., "IBM Type 650 Magnetic Tape Attachment", IBM Technical Newsletter, No.10, IBM, New York (Oct 1955), pp.264-269.
  16. Sweeney, Dura W., and George R. Trimble, Jr., "IBM Type 650 High Speed Storage Attachment", IBM Technical Newsletter, No.10, IBM, New York (Oct 1955), pp.270-276.
  17. Trimble, G.R., Jr., and E.C. Kubie, "Principles of Optimum Programming the IBM Type 650", IBM Technical Newsletter, No.8, IBM, New York (Sep 1954), pp.5-16.
  18. Trimble, G.R., Jr., and E.C. Kubie, "Indexing Accumulators for the IBM Type 650", IBM Technical Newsletter, No.10, IBM, New York (Oct 1955), pp.253-263.
  19. Numerous other articles in IBM Scientific Computing Forum Proceedings and Technical Newsletters from 1954 on, describing 605 applications and techniques.

Links (all valid as of 3 July 2003):

Thanks to Diarmuid Pigott for corrections to the list of IBM 650 programming languages.

Most recent update: Fri Oct 25 17:07:23 2013


Frank da Cruz / fdc@columbia.edu / Columbia University Computing History