1 History

1.1 Development and origins

The IBM 704 was developed in the early 1950s as a successor to the IBM 701, the company’s first electronic stored-program computer. IBM’s engineers sought to create a machine that could handle scientific calculations more efficiently by incorporating hardware support for floating-point arithmetic, a feature that had previously required software emulation or additional specialized units. The project was led by senior engineers at IBM’s Poughkeepsie laboratory, with key contributions from designers such as Gene Amdahl (later known for Amdahl’s Law). The system was announced in 1954 and quickly became the standard large-scale computer for scientific and engineering applications.

1.1.1 Relationship with the IBM 701 and 702

The IBM 704 shared the same general vacuum-tube technology and 36‑bit word length as the earlier IBM 701, but it introduced several critical architectural improvements. Unlike the 701, which had no floating-point hardware and used a separate arithmetic unit for multiplication and division, the 704 integrated full floating-point arithmetic into its central processor. It also moved away from the IBM 702’s business-oriented decimal design, focusing squarely on binary scientific computing. The 704 thus combined the 701’s binary foundation with expanded instruction sets and memory addressing, forming a bridge to the later IBM 709 and 7090 series.

1.2 Deployment and upgrades

IBM delivered the first 704 systems to customers in late 1955. The machine was marketed as a “large-scale electronic data processing machine” and was typically leased rather than sold. Over the next few years, IBM offered several upgrade options, including additional core memory modules (expanding from 4,096 words to 32,768 words) and faster input/output channels. Field upgrades were common, allowing early installations to increase capacity without replacing the entire system.

1.2.1 Notable installations (e.g., MIT, Livermore)

The IBM 704 was installed at numerous leading research institutions and government laboratories. The Massachusetts Institute of Technology (MIT) operated a 704 that became the host for early experiments in time-sharing and artificial intelligence research. The Lawrence Livermore National Laboratory (then Livermore Radiation Laboratory) used multiple 704 systems to simulate nuclear reactions and weapon designs as part of the U.S. nuclear weapons program. Other notable sites included the Los Alamos Scientific Laboratory, the Boeing Company, and the U.S. Naval Ordnance Laboratory. These installations often featured custom peripherals and specialized software tailored to local needs.

1.3 End of production and successor machines

IBM ceased production of the 704 in the early 1960s, having delivered approximately 140 units. The machine was succeeded by the transistorized IBM 7090 (announced 1958, delivered 1960), which offered significantly higher speed and reliability. The 7090’s architecture was directly derived from the 704, and many 704 software applications—especially FORTRAN programs—could be run on the 7090 with minimal modification. The 704 thus formed the foundation of IBM’s dominant line of scientific mainframes until the introduction of the System/360 in 1964.

2 Architecture

2.1 Central processing unit

The IBM 704 central processing unit (CPU) was built primarily from vacuum tubes and discrete components, with a clock speed of about 40 kHz. It executed instructions sequentially and had no internal pipelining. The CPU included a fixed-point arithmetic unit for integer operations and a dedicated floating-point unit that handled both addition and multiplication in hardware. Boolean logic circuits controlled instruction decoding and data routing.

2.1.1 Data word format (36-bit, single- and double-precision)

All data in the IBM 704 was stored as 36‑bit words. For floating-point numbers, the single-precision format used 8 bits for the exponent (biased by 128) and 27 bits for the mantissa, with one sign bit. Double-precision operations combined two consecutive 36‑bit words to form a 72‑bit representation, offering greater precision for scientific calculations. The architecture also supported half-word (18‑bit) fixed-point integers and 6‑bit alphanumeric characters for punched card data.

2.1.2 Instruction set and addressing modes

The 704’s instruction set comprised single-address instructions stored in a 36‑bit word. Each instruction contained a 6‑bit operation code, an 18‑bit address field (capable of directly addressing up to 32,768 words), and a 3‑bit tag field for index register selection. Instructions included arithmetic operations (add, subtract, multiply, divide), logical operations, conditional branches, memory loads and stores, and input/output commands. The addressing modes were direct (the address field specified a memory location) and indirect (via a single level of indirection), with the tag field enabling indexed addressing.

2.1.2.1 Index registers and indirect addressing

The IBM 704 was one of the first commercial computers to incorporate three index registers (designated A, B, and C). These 15‑bit registers allowed programmers to modify instruction addresses dynamically without rewriting program code. When an instruction’s tag field indicated an index register, the register’s contents were added to the address field before memory access. Indirect addressing, signaled by a special bit in the instruction word, caused the CPU to fetch the effective address from the location given in the address field, enabling flexible data structures and subroutine calls.

2.2 Memory system

2.2.1 Magnetic core memory configuration

The IBM 704 used magnetic core memory as its main storage medium, replacing the earlier electrostatic storage (Williams tubes) used in the IBM 701. Each core plane consisted of tiny ferrite rings threaded with wires, storing one bit per core. The standard initial configuration provided 4,096 words of 36 bits each, organized in a single memory bank. Additional memory units could be added to reach up to 32,768 words. Core memory was non-volatile, meaning data persisted when power was removed, a significant improvement over vacuum-tube-based storage.

2.2.2 Cycle time and capacity options

The magnetic core memory in the IBM 704 had a cycle time of about 12 microseconds per access. This meant the CPU could read or write one word every 12 µs, yielding a maximum memory bandwidth of roughly 3 million words per second. Memory expansion options were available as field upgrades: standard capacities included 4K, 8K, 16K, and 32K words (where K = 1,024). Users could lease additional core units from IBM as needed, paying per thousand words per month.

2.3 Input/output and peripherals

2.3.1 Card readers, printers, and tape drives

The IBM 704 was typically equipped with an IBM 711 card reader (150 cards per minute), an IBM 716 printer (150 lines per minute), and multiple IBM 727 magnetic tape drives. Tape drives used 7‑track half-inch tape at a density of 200 characters per inch, with a transfer rate of about 7,500 characters per second. The system also supported punched paper tape readers, punched card punches, and auxiliary storage units such as magnetic drums. Input/output operations could be overlapped with computation through a separate I/O channel, but the 704 lacked the full channel architecture of later systems.

2.3.2 Console and operator interface

The operator’s console of the IBM 704 was a large desk-like unit featuring rows of indicator lights, toggle switches, and a typewriter-like keyboard. Lights displayed the contents of the accumulator, index registers, and selected memory locations. Switches allowed manual entry of instructions and data, as well as control of the machine’s mode (run, stop, single-step). A “sense switches” panel provided four switches that could be read by software, enabling the operator to guide program flow. The console also included a “stop” button and a “reset” button for emergency halts. Operators often used the console to load small diagnostic programs or examine memory after a crash.

3 Software

3.1 Programming languages

3.1.1 FORTRAN (original implementation)

The IBM 704 was the target platform for the first FORTRAN compiler, developed by a team led by John Backus at IBM. Released in 1957, the FORTRAN system allowed programmers to write scientific computations in a high-level language, which was then compiled into efficient 704 machine code. The compiler produced code that often matched hand-written assembly in performance, a remarkable feat for its time. FORTRAN on the 704 introduced many features still in use today, including the DO loop, arithmetic IF, and formatted I/O. The success of FORTRAN on the 704 helped establish high-level programming as a standard practice.

3.1.2 Assembly language (SAP – Symbolic Assembly Program)

The primary assembly language for the IBM 704 was the Symbolic Assembly Program (SAP), developed by IBM in the mid‑1950s. SAP allowed programmers to write instructions using mnemonic operation codes (e.g., CLA for “clear and add”, STO for “store”) and symbolic addresses, which the assembler resolved to machine addresses. The assembler also supported pseudo‑operations for defining constants, allocating storage, and generating literal pools. SAP became the standard tool for systems programming and performance-critical applications, forming the basis for later assemblers on IBM 700‑series machines.

3.2 Operating systems and utilities

3.2.1 Early batch processing monitors

The IBM 704 did not run a full operating system in the modern sense. Instead, it used rudimentary batch processing monitors, often written in SAP, that automated job sequencing. These monitors controlled the loading of programs from tape or punched cards, managed I/O device assignments, and handled error recovery. One well-known example was the Fortran Monitor System (FMS), which coordinated the compilation and execution of FORTRAN jobs. Another was the SHARE Operating System (SOS), developed by the SHARE user group, which provided more advanced job control and file handling. These monitors laid the groundwork for later operating systems like IBSYS.

3.2.2 Utility programs and subroutine libraries

IBM supplied a set of standard utility programs for the 704, including a card-to-tape converter, a tape copy utility, a memory dump program (known as “SYMDMP” or similar), and a diagnostic test suite called the “Maintenance Diagnostic Program.” Scientific subroutine libraries were distributed as pre‑assembled decks of punched cards, covering functions such as matrix inversion, Bessel functions, random number generation, and numerical integration. The SHARE user group also maintained a large library of contributed subroutines, which members could share and modify.

4 Impact and legacy

4.1 Influence on subsequent IBM systems

The IBM 704’s architecture directly shaped the design of later IBM 700/7000 series machines, particularly the IBM 709 and the transistorized IBM 7090/7094. Many of the 704’s features—floating-point hardware, index registers, magnetic core memory, and the 36‑bit word—were retained and enhanced. The 704’s instruction set formed the basis for the compatibility that allowed FORTRAN programs to migrate seamlessly to the 7090. Furthermore, the design concepts pioneered in the 704, such as hardware floating-point arithmetic and multi‑level indirect addressing, influenced IBM’s System/360 and many later mainframe families.

4.2 Role in scientific and engineering computing

4.2.1 Use in nuclear simulation and aerospace research

The IBM 704 was instrumental in early nuclear weapons design and fusion research. At Livermore and Los Alamos, scientists used the 704 to run Monte Carlo simulations of neutron transport and hydrodynamic codes for weapon modeling. In the aerospace sector, the 704 was employed at NASA and at companies like Boeing and McDonnell Aircraft for aerodynamic calculations, trajectory analysis, and structural stress simulations. The machine also supported early weather prediction models and theoretical physics research.

4.3 Cultural and historical significance

The IBM 704 appears in early computing lore as the machine on which legendary programmer John McCarthy developed the concept of time‑sharing (at MIT) and where artificial intelligence pioneers such as Marvin Minsky ran early pattern‑recognition experiments. It is also mentioned in the memoirs of computer scientist Grace Hopper, who worked with early IBM machines. Although not as widely depicted as later systems, the 704 occasionally appears in historical documentaries about the advent of computing. One notable reference is in the 1957 film “The Desk Set,” where a fictional large computer (modeled loosely on the IBM 704) is used to manage corporate data, though the actual machine shown was a different IBM system. The 704’s distinctive control panel and large floor‑standing cabinets remain iconic images of the vacuum‑tube era of computing.