IBM 650
| Company type | Computer |
|---|---|
| Industry | Computing hardware |
| Founded | 1953 |
| Headquarters | Armonk , United States |
| Products | Digital computer |
The IBM 650 Magnetic Drum Data-Processing Machine was one of the pioneering digital computers developed by IBM during the mid-1950s and holds the distinction of being the first computer to be mass-produced worldwide. Approximately 2,000 units were manufactured up until 1962, establishing it as IBM’s best-selling computer throughout that decade and the first model to deliver substantial profitability. Its debut installation took place in late 1954.
Designed to serve business, scientific, and engineering sectors, the IBM 650 provided a cost-effective and slower alternative compared to the more advanced IBM 701 and IBM 702 models. It also attracted users transitioning from punched card machines such as the IBM 604. Thanks to its affordability and relatively straightforward programming, it supported a wide range of uses—from simulating submarine crew operations to academic instruction—becoming a prevalent tool in university programming education.
Introduced in 1953, the IBM 650 received an upgrade in 1956 with the IBM 650 RAMAC, which included up to four disk storage units. The base console was priced at $150,000 in 1959, equivalent to around $1.5 million in 2023 currency. Official support for the machine concluded in 1969.
From a technical standpoint, the IBM 650 was a two-address machine that employed bi-quinary coded decimal representation and utilized magnetic drum memory. Its input/output devices transformed punched card characters into decimal codes. Operating at a clock speed of 125 kHz, it executed addition and subtraction in approximately 1.63 milliseconds, multiplication in about 13 milliseconds, and division in under 17 milliseconds—yielding an average throughput near 40 instructions per second.
Significantly, Donald Knuth dedicated his foundational text The Art of Computer Programming to this computer.
History
The very first IBM 650 installation occurred on December 8, 1954, within the controller’s office at John Hancock Mutual Life Insurance Company located in Boston.
The IBM 7070, announced in 1958 with signed decimal words of ten digits, was designed as a replacement for both the IBM 650 and IBM 705 models. Introduced in 1959, the IBM 1620 featured variable-length decimal capability aimed at entry-level markets. In response to the IBM 650, Sperry Rand launched the UNIVAC Solid State—a two-address computer revealed in December 1958. However, none of these successors maintained compatibility with the IBM 650’s instruction set.
Hardware
The IBM 650 system consisted primarily of three components:
- IBM 650 Console Unit: containing magnetic drum memory, vacuum tube-based arithmetic logic units, and the operator’s control panel.
- IBM 655 Power Unit
- IBM 533 or IBM 537 Card Read Punch Unit: The IBM 533 had distinct feeds for reading and punching cards; conversely, the IBM 537 combined these functions into one feed mechanism.
The entire system’s weight ranged from roughly 5,400 to over 6,200 pounds.
Additional optional devices enhanced its capabilities:
- IBM 46 Tape To Card Punch, Model 3
- IBM 47 Tape To Card Printing Punch, Model 3
- IBM 355 Disk Storage Unit: Machines equipped with this unit were marketed as IBM 650 RAMAC Data Processing Systems.
- IBM 407 Accounting Machine
- IBM 543 Card Reader Unit
- IBM 544 Card Punch Unit
- IBM 652 Control Unit (managing magnetic tape and disk operations)
- IBM 653 Storage Unit (providing magnetic tape, disk storage, core memory, index registers, and floating-point arithmetic)
- IBM 654 Auxiliary Alphabetic Unit
- IBM 727 Magnetic Tape Unit
- IBM 838 Inquiry Station
Main memory
The rotating drum memory offered capacity options of 1,000, 2,000, or 4,000 words, addressed from 0000 up to 0999, 1999, or 3999 respectively. Each word contained 10 bi-quinary coded decimal digits, which could represent either a signed 10-digit number or five characters. Considering each bi-quinary digit as seven bits, the largest memory size of 4,000 words corresponded to roughly 35 kilobytes. Words were arranged in bands encircling the drum—each band held fifty words, with the number of bands being 20, 40, or 80 depending on the specific model. Access to data occurred as the drum rotated at 12,500 rpm and the word passed beneath the read/write heads, resulting in an average access time of approximately 2.5 ms without optimization. To improve timing efficiency, the second address field in each instruction indicated the location of the subsequent instruction, allowing programmers to strategically place instructions for immediate retrieval after execution. IBM supplied a form to assist with tracking instruction and data positioning; later on, the assembler SOAP (Symbolic Optimal Assembly Program) provided rudimentary optimization capabilities.
While the LGP-30, Bendix G-15, and IBM 305 RAMAC also utilized vacuum tubes and drum memory technology, their designs differed markedly from that of the IBM 650.
Instructions fetched from the drum were loaded into a program register (instruction register), while data was routed through a 10-digit distributor. The IBM 650 included a 20-digit accumulator, divided into lower and upper segments of ten digits each sharing a common sign. Arithmetic operations employed a single-digit adder. The console—comprising ten digit switches, one sign switch, and ten bi-quinary display lights—as well as the distributor and accumulators could be addressed at locations ranging from 8000 to 8003.
IBM 653 Storage Unit
Launched on May 3, 1955, the optional IBM 653 Storage Unit introduced up to five enhancements:
- A magnetic tape controller compatible with IBM 727 Magnetic Tape units, adding ten operation codes
- A disk storage controller (introduced in 1956) designed for the IBM 355 Disk Storage Unit, providing five additional operation codes
- Sixty words of rapid magnetic core memory accessible at addresses 9000–9059 with a swift access time of 96μs—representing a speed increase by a factor of twenty-six compared to drum memory—used primarily as a buffer for tape/disk I/O operations and to accelerate inner loops and table lookups; this feature added five operation codes
- Three four-digit index registers located at addresses 8005–8007 that enabled address indexing by adding offsets to drum or core memory addresses; indexing capabilities varied according to system size and required transistorized read/write circuitry on earlier 4000-word drums produced before 1963; this functionality introduced eighteen extra operation codes
- Floating point arithmetic support featuring an eight-digit mantissa alongside a two-digit characteristic (offset exponent) formatted as MMMMMMMMCC, covering ranges from ±0.00000001E-50 up to ±0.99999999E+49; this added seven new operation codes
Instruction set
The instruction format for the IBM 650 consisted of a two-digit operation code, followed by a four-digit data address and another four-digit address pointing to the next instruction. The basic configuration disregarded sign information; however, machines equipped with optional features made use of it. The standard model supported forty-four operation codes initially, with additional codes available for options such as floating point support, core memory utilization, index registers, and supplementary I/O devices. When fully expanded, the machine could execute up to ninety-seven distinct operation codes.
The Table Lookup (TLU) instruction allowed comparison of a referenced ten-digit word against forty-eight consecutive words within the same drum band during one full five-millisecond revolution; after completing one band, it could proceed to compare another forty-eight words on the subsequent band. This performance represented roughly one-third of the speed achievable by binary machines like the IBM 7040 in 1963 when both were programmed using assembler language. An optional Table Lookup Equal instruction matched this performance level.
The Read (RD) instruction transferred an eighty-column numeric card into ten consecutive memory words; how digits were distributed depended on wiring configurations in the card reader's control panel. When paired with the Alphabetic device in the IBM 533 Reader Punch unit, it could handle reading up to thirty alphanumeric columns. An expansion option permitted reading additional alphanumeric columns but was constrained by available storage capacity to approximately fifty characters.
Operation codes available in the base machine included:
| 17 | AABL | Add absolute value to lower accumulator |
| 15 | AL | Add value to lower accumulator |
| 10 | AU | Add value to upper accumulator |
| 45 | BRNZ | Branch if accumulator is non-zero |
| 46 | BRMIN | Branch if accumulator is negative |
| 44 | BRNZU | Branch if upper accumulator is non-zero |
| 47 | BROV | Branch on overflow condition |
| 90-99 | BRD | Branch based on '8' in distributor positions one through ten (used for CPU signaling via IBM 533 control panel) |
| 14 | DIV | Divide operation |
| 64 | DIVRU | Divide and reset upper accumulator |
| 69 | LD | Load distributor register |
| 19 | MULT | Multiply operation |
| 00 | NO-OP | No operation performed |
| 71 | PCH | Punch card output operation |
| 70 | RD | Read card input operation |
| 67 | RAABL | Reset accumulator then add absolute value to lower accumulator |
| 65 | RAL | Reset accumulator then add value to lower accumulator |
| 60 | RAU | Reset accumulator then add value to upper accumulator |
| 68 | RSABL | Reset accumulator then subtract absolute value from lower accumulator |
| 66 | RSL | Reset accumulator then subtract value from lower accumulator |
| 61 | RSU | Reset accumulator then subtract value from upper accumulator |
| 35 | SLT | "Shift left" operation on accumulator |
| Code | Mnemonic | Description |
|---|
Additional instruction codes could be implemented through IBM 653 options.
Sample program
This single-card example, taken from the 650 Programming Bulletin 5, IBM, 1956, initializes most of the drum memory to minus zero values. It illustrates the use of instructions entered via console switches alongside accumulator operations.
An 80-digit load card is punched so that drum addresses 0001 through 0008 contain the following data:
0001 0000010000
0002 0000000000-
0003 1000018003
0004 6100080007
0005 2400008003
0006 0100008000
0007 6900060005
0008 2019990003
The console digit switches at address 8000 are manually configured to a Read (RD) instruction targeting data address 0004:
8000 RD 70 0004 xxxx
This command loads the contents of the card into the initial band read area, spanning locations 0001 to 0010. The band identifier is given by address 0004. Execution begins at the console, reading eight words into locations 0001 through 0008. For load cards, the next instruction’s address is specified by the data address field, so processing continues at location 0004.
Subsequent instructions execute as follows:
0004 RSU 61 0008 0007 Reset accumulator and subtract value at location 2019990003 into upper accumulator
0007 LD 69 0006 0005 Load distributor register with data from location 0100008000
0005 STD 24 0000 8003 Store distributor in location 0000; next instruction address stored in upper accumulator (8003)
Transferring data between drum locations requires the use of LD and STD instructions.
A two-instruction loop then operates as follows:
8003 STL 20 1999 0003 Store lower accumulator and decrement the data address each iteration
0003 AU 10 0001 8003 Decrement the instruction’s data address by one
The STL instruction’s data address is reduced on each cycle until it reaches location 0003, at which point the AU instruction at location 0003 is overwritten with zeros. Execution then proceeds with:
0003 NOOP No operation; next instruction at address 0000
0000 HALT Halt execution; control returns to console at address 8000
The HALT instruction stored at location 0000 was placed there earlier by the STD command.
Software
Due to its straightforward instruction set, the IBM 650 allowed small programs to be crafted directly in machine code, a method frequently employed for educational purposes. The format of one instruction per punched card facilitated immediate loading and execution.
Because machine language proved inefficient for more complex software, a variety of programming languages and tools emerged for the IBM 650, including:
- Assemblers
- Symbolic Optimal Assembly Program (SOAP) — an assembler
- Technical Assembly System (TASS) — a macro assembler
- Interpretive systems
- The Complete Floating Decimal Interpretive System, also called the Wolontis–Bell Labs Interpreter or BLIS (Bell Lab Interpretive System), offered a virtual machine environment for applications.
- L1 and L2 — interpretive languages developed at Bell Labs, sometimes referred to as "Bell 1" and "Bell 2"
- Synthetic Programming System for Commercial Applications — built upon concepts derived from Bell Laboratories’ interpretive system
- Algebraic languages / compilers
- Internal Translator (IT) — a compiler designed for the IBM 650
- Revised Unified New Compiler IT Basic Language Extended (RUNCIBLE) — an IT extension developed at Case Institute of Technology, recognized as Donald Knuth’s initial academic work
- FOR TRANSIT — a Fortran variant compiling first to IT, then to SOAP
- FORTRAN — IBM’s FORTRAN Automatic Coding System adapted specifically for the IBM 650
Other programming options included:
- GATE — a basic compiler utilizing single-letter variable names
- IPL — recognized as the pioneering list processing language, with IPL-V being its most prominent version
- SPACE (Simplified Programming Anyone Can Enjoy) — a business-focused two-step compiler built on SOAP
These software innovations significantly broadened the IBM 650’s utility in both scientific research and commercial applications, enhancing its value through improved programming flexibility and efficiency.
See also
- Ferranti Mark 1
- History of IBM#1946–1959: Postwar
- IBM 700/7000 series
- Bull Gamma 3, a principal rival to the IBM 650
- LEO (computer)
- List of vacuum-tube computers
- Short Code
- UNIVAC I
- UNIVAC Solid State, unveiled by Sperry Rand in December 1958 as a competitive response to the IBM 650; Remington Rand introduced an IBM 650 emulator in June 1959 to aid in system transition.
Further reading
External links
- Bitsavers.org: IBM 650 documentation (PDF format)
- Columbia University: The IBM 650 at Columbia University
- Contains timeline, technical details, client information, and usage examples.
- Video footage of IBM 650 and RAMAC functioning
- Comprehensive analysis including customers, applications, specifications, and pricing.