IBM 650

thumb|IBM 650 at Texas A&M University. The IBM 533 Card Read Punch unit is on the right.

[[File:IBM 650.002 - MUNCYT.jpg|thumb|IBM 650 console panel, showing bi-quinary indicators. It was the first mass-produced computer in the world. Almost 2,000 systems were produced, the last in 1962,

The 650 was offered to business, scientific and engineering users as a slower and less expensive alternative to the IBM 701 and IBM 702 computers, which were for scientific and business purposes respectively. It was also marketed to users of punched card machines who were upgrading from calculating punches, such as the IBM 604, to computers.

Because of its relatively low cost and ease of programming, the 650 was used to pioneer a wide variety of applications, from modeling submarine crew performance to teaching high school and college students computer programming. The IBM 650 became highly popular in universities, where a generation of students first learned programming.

It was announced in 1953 and in 1956 enhanced as the IBM 650 RAMAC with the addition of up to four disk storage units. The purchase price for the bare IBM 650 console, without the reader punch unit, was $150,000 in 1959, or roughly $1,500,000 as of 2023. Support for the 650 and its component units was withdrawn in 1969.

The 650 was a two-address, bi-quinary coded decimal computer (both data and addresses were decimal), with memory on a rotating magnetic drum. Character support was provided by the input/output units converting punched card alphabetical and special character encodings to/from a two-digit decimal code.

The 650 was clocked at a frequency of 125 kHz. It could add or subtract in 1.63 milliseconds, multiply in 12.96 ms, and divide in 16.90 ms. The average speed of the 650 was estimated to be around 27.6 ms per instruction, or roughly 40 instructions per second.

Donald Knuth's series of books The Art of Computer Programming is famously dedicated to a 650.

The IBM 7070 (signed 10-digit decimal words), announced 1958, was expected to be a "common successor to at least the 650 and the [[IBM 705|[IBM] 705]]". The IBM 1620 (variable-length decimal), introduced in 1959, addressed the lower end of the market. The UNIVAC Solid State (a two-address computer, signed 10-digit decimal words) was announced by Sperry Rand in December 1958 as a response to the 650. None of these had an instruction set that was compatible with the 650.

Hardware

The basic 650 system consisted of three units:

IBM 650 Console Unit housed the magnetic drum storage, arithmetical device (using vacuum tubes) and the operator's console.
IBM 655 Power Unit
IBM 533 or IBM 537 Card Read Punch Unit The IBM 533 had separate feeds for reading and punching; the IBM 537 had one feed, thus could read and then punch into the same card.

Weight: .

Optional units: Systems with a disk unit were known 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 (magnetic tape, disk)
IBM 653 Storage Unit (magnetic tape, disk, core storage, index registers, floating-point arithmetic)
IBM 654 Auxiliary Alphabetic Unit
IBM 727 Magnetic Tape Unit
IBM 838 Inquiry Station

Main memory

Rotating drum memory provided 1,000, 2,000, or 4,000 words of memory at addresses 0000 to 0999, 1999, or 3999 respectively. Each word had 10 bi-quinary coded decimal digits, representing a signed 10-digit number or five characters. (Counting a bi-quinary coded digit as seven bits, 4000 words would be equivalent to 35 kilobytes.) Words on the drums were organized in bands around the drum, fifty words per band, and 20, 40, or 80 bands for the respective models. A word could be accessed when its location on the drum surface passed under the read/write heads during rotation (rotating at 12,500 rpm, the non-optimized average access time was 2.5 ms). Because of this timing, the second address in each instruction was the address of the next instruction. Programs could then be optimized by placing instructions at addresses that would be immediately accessible when execution of the previous instruction was completed. IBM provided a form with ten columns and 200 rows to allow programmers to keep track of where they put instructions and data. Later an assembler, SOAP (Symbolic Optimal Assembly Program), was provided that performed rough optimization.

The Table lookup (TLU) instruction could high-equal compare a referenced 10-digit word with 48 consecutive words on the same drum band in one 5ms revolution and then switch to the next band in time for the next 48 words. This feat was about one-third the speed of a one-thousand times faster binary machine in 1963 (1,500 microseconds on the IBM 7040 to 5,000 microseconds on the 650) for looking up 46 entries as long as both were programmed in assembler. There was an optional Table lookup Equal instruction, with the same performance.

The Read (RD) instruction read an 80-column card of numeric data into ten memory words; the distribution of digits to words determined by the card reader's control panel wiring. When used with the 533 Reader Punch unit's Alphabetic device, a combination of numeric and alphanumeric columns (maximum of 30 alphanumeric columns) could be read.

{| class="wikitable"

|17

|AABL

|Add absolute to lower accumulator

|15

|AL

|Add to lower accumulator

|10

|AU

|Add to upper accumulator

|45

|BRNZ

|Branch on accumulator non-zero

|46

|BRMIN

|Branch on minus accumulator

|44

|BRNZU

|Branch on non-zero in upper accumulator

|47

|BROV

|Branch on overflow

|90-99

|BRD

|Branch on 8 in distributor positions 1-10

|14

|DIV

|Divide

|64

|DIVRU

|Divide and reset upper accumulator

|69

|LD

|Load distributor

|19

|MULT

|Multiply

|00

|NO-OP

|No operation

|71

|PCH

|Punch a card

|70

|RD

|Read a card

|67

|RAABL

|Reset accumulator and add absolute to lower accumulator

|65

|RAL

|Reset accumulator and add to lower accumulator

|60

|RAU

|Reset accumulator and add to upper accumulator

|68

|RSABL

|Reset accumulator and subtract absolute from lower accumulator

|66

|RSL

|Reset accumulator and subtract from lower accumulator

|61

|RSU

|Reset accumulator and subtract from upper accumulator

|35

|SLT

|Shift accumulator left

|36

|SCT

|Shift accumulator left and count

|30

|SRT

|Shift accumulator right

|31

|SRD

|Shift accumulator right and round accumulator

|01

|STOP

|Stop if console switch is set to stop, otherwise continue as a NO-OP

|24

|STD

|Store distributor into memory

|22

|STDA

|Store lower accumulator data address into distributor

Then store distributor into memory

|23

|STIA

|Store lower accumulator instruction address into distributor

Then store distributor into memory

|20

|STL

|Store lower accumulator into memory

|21

|STU

|Store upper accumulator into memory.

|18

|SABL

|Subtract absolute from lower accumulator

|16

|SL

|Subtract from lower accumulator

|11

|SU

|Subtract from upper accumulator

|84

|TLU

|Table lookup

Notes:

The IBM 653 options could implement additional instruction codes.

0001 0000010000

0002 0000000000-

0003 1000018003

0004 6100080007

0005 2400008003

0006 0100008000

0007 6900060005

0008 2019990003

The console digit switches (address 8000) are manually set to a Read instruction with data address 0004.

loc- op|data|next

ation |addr|instruction

| |addr

8000 RD 70 0004 xxxx Read load card into first band read area

Each drum band has a read area; these read areas are in locations 0001-0010, 0051-0060, 0101-0110 and so on. Any address in a band can be used to identify that band for a read instruction; the address 0004 identifies the first band. Execution begins then, from the console with the reading of the eight words on the load card into locations 0001-0008 of the first memory band. In the case of reading a load card, the "next instruction address" is taken from the data address field, not the next instruction address field (shown above as xxxx). Thus execution continues at 0004

0004 RSU 61 0008 0007 Reset entire accumulator, subtract into upper (8003) the value 2019990003

0007 LD 69 0006 0005 Load distributor with 0100008000

0005 STD 24 0000 8003 Store distributor in location 0000, next instruction is in 8003 (the upper accumulator)

Note: the moving of data or instructions from one drum location to another

requires two instructions: LD, STD.

Now a two-instruction loop executes:

8003 STL 20 1999 0003 Store lower accumulator (that accumulator was reset to 0- by the RSU instruction above)

The "1999" data address is decremented, below, on each iteration.

This instruction was placed in the upper accumulator by the RSU instruction above.

Note: this instruction, now in the upper accumulator, will be decremented and then

executed again while still in the accumulator.

0003 AU 10 0001 8003 Decrement data address of the instruction in the accumulator by 1

(by adding 10000 to a negative number)

The STL's data address will, eventually, be decremented to 0003, and the AU ... instruction at 0003 will be overwritten with zeros. When that occurs (the STL's next instruction address remains 0003) execution continues as follows:

0003 NOOP 00 0000 0000 No-operation instruction, next instruction address is 0000

0000 HALT 01 0000 8000 Halt, next instruction address is the console

(this Halt instruction was stored in 0000 by the STD instruction above)

Software

[[File:IBM 650 student program 1961.agr.jpg|thumb|Student program from 1961 written in IBM 650 machine language, based on an exercise in Andree's book There was a single-instruction-per-card format that could be loaded directly into the machine and executed.

Machine language was awkward for large programs and, over time, a variety of programming languages and tools were

written for the IBM 650. These included:

; Assemblers

Symbolic Optimal Assembly Program (SOAP) — An assembler
Technical Assembly System (TASS) — A macro assembler.

; Interpretive systems

An Interpretive application virtual machine package originally published as "Complete Floating Decimal Interpretive System for the IBM 650 Magnetic Drum Calculator". This was known by several names:
the Wolontis–Bell Labs Interpreter, the Bell System, the Bell interpreter, the Bell interpretive system, or BLIS — the Bell Lab Interpretive System
L1 and (later) L2 – known outside Bell Labs as "Bell 1" and "Bell 2", among other names (see above)
Synthetic Programming System for Commercial Applications

; Algebraic languages / compilers

Internal Translator (IT) — A compiler
Revised Unified New Compiler IT Basic Language Extended (RUNCIBLE) — An extension of IT at Case
FOR TRANSIT — A version of Fortran which compiled to IT which in turn was compiled to SOAP
FORTRAN

GATE — A simple compiler with one character variable names
IPL — The first list processing language. The best-known version was IPL-V.
SPACE (Simplified Programming Anyone Can Enjoy) — A business-oriented two-step compiler through SOAP

Notes and references

External links

Bitsavers.org: IBM 650 documents (PDF files)
Columbia University: The IBM 650 at Columbia University
Includes a chronology, technical specifications, photographs, representative customers, and applications the 650 was used for.
Video clip of IBM 650 and RAMAC in operation, alternate version
Includes about 40 pages of IBM 650 survey detail: customers, applications, specifications, and costs.

<!------------------

An IBM 650 Simulator written in Python
An IBM 650 assembler and Byte code interpreter - Written in Perl at archive.org
IBM 650 assembler and byte code interpreters

These appear to be modern, student, implementations of 650 interpreters thus would not seem to be appropriate Wikipedia links/references. Leaving this comment in text so as to, hopefully, avoid the 4th, 5th ...

-------------------->

Hardware

Main memory

Software

See also

Notes and references

Further reading

External links