Fact-checked by Grok 2 weeks ago

IBM 709

The IBM 709 was a large-scale, vacuum-tube-based mainframe computer developed by International Business Machines Corporation (IBM), announced on January 2, 1957, and first delivered in August 1958.^[1]^[2] Designed primarily for scientific, engineering, commercial, and management applications requiring high-speed data processing, it succeeded the IBM 704 with enhanced performance and input-output flexibility while maintaining compatibility for existing programs.^[3]^[4] Key to its design was a magnetic core storage unit offering up to 32,768 words of 36-bit capacity, equivalent to more than 327,000 decimal digits, supplemented by magnetic drums for auxiliary storage of over 163,000 decimal digits and magnetic tapes for up to half a billion digits.^[3] The central processing unit executed most instructions, such as addition and subtraction, in 24 microseconds, with core memory access times of 12 microseconds, and supported over 180 instructions including floating-point operations, indexing via three dedicated registers, and indirect addressing for streamlined programming.^[3] Input-output capabilities were revolutionized by the new Data Synchronizer, which allowed simultaneous operations across up to three channels and supported configurations of up to 48 tape units, three card readers, three punches, and three printers, along with automatic error-checking on tapes.^[3] The IBM 709 represented a pinnacle of vacuum-tube technology, introducing direct memory access (DMA) to enable independent I/O processing without interrupting the CPU.^[5] Its production run was brief, however, ending with withdrawal from marketing on April 7, 1960, as it was rapidly eclipsed by the transistorized IBM 7090 announced in 1958.^[1]^[2] Notable deployments included NASA's Project Vanguard for satellite tracking calculations and early time-sharing experiments at MIT, which laid groundwork for multi-user computing systems.^[6]^[7]

Introduction and Specifications

Overview

The IBM 709 was a computer system announced by International Business Machines (IBM) in January 1957 and first installed in August 1958.^[1] It represented an improved version of the IBM 704, serving as a key model in IBM's 700/7000 series of large-scale computers and acting as the direct predecessor to the transistorized IBM 7090.^[8] Designed as a vacuum-tube mainframe, the IBM 709 was primarily intended for scientific and engineering computations, such as missile trajectory calculations and engineering analysis.^[8] Notable innovations included overlapped input/output operations allowing up to three IBM 766 Data Synchronizers, each providing two channels for a total of up to six data channels to function concurrently with the central processing unit, indirect addressing supported by three index registers for flexible memory access, and three dedicated convert instructions to facilitate binary-decimal data type handling.^[8]^[3] Physically, the IBM 709's central processing unit weighed 2,110 pounds, while the complete system required significant infrastructure, consuming 100 to 250 kilowatts of power depending on configuration.^[8] It employed magnetic-core memory, ranging from 4,096 to 32,768 36-bit words with a 12-microsecond access time, marking an advancement in reliable, high-speed storage for the era.^[8]

Technical Specifications

The IBM 709 was equipped with configurable magnetic-core storage ranging from 4,096 to 32,768 words of 36-bit capacity, providing up to over 327,000 decimal digits.^[3] This core memory had an access time of 12 microseconds.^[8] The processor supported a 36-bit word length for both instructions and data, enabling efficient handling of scientific and commercial computations.^[3] It achieved processing speeds of 42,000 fixed-point additions or subtractions per second and 5,000 multiplications per second.^[3] The system relied on vacuum-tube technology.^[8] For input/output, the IBM 709 supported up to three independent IBM 766 Data Synchronizers, allowing connection to peripherals such as up to 48 magnetic tape units.^[3] This design facilitated overlapped I/O, enabling concurrent computation and data transfer.^[5] In typical installations including peripherals, the overall system footprint weighed around 31,810 lbs.^[8]

History and Development

Origins and Design

The IBM 709 emerged as a direct evolution from the IBM 704, addressing key limitations in input/output (I/O) capabilities and memory addressing that had constrained the earlier system's handling of large-scale scientific computations. The 704 relied on programmed I/O, which tied up the central processor during data transfers, leading to inefficiencies in environments requiring extensive peripheral interactions. To overcome this, the 709 introduced dedicated "Data Synchronizer" channels—up to six programmable direct memory access (DMA) units—that allowed asynchronous I/O operations, enabling the processor to continue computing while data moved between memory and peripherals like magnetic tapes. This design choice significantly improved throughput for data-intensive tasks, building directly on operational feedback from 704 installations at research and defense sites.^[9]^[8] Design goals for the 709 centered on enhancing scientific computing for complex problems in defense, engineering, and research, where reliability and scalability were paramount for military applications such as simulations and trajectory calculations. Engineers emphasized robust vacuum-tube circuitry to ensure high uptime in mission-critical settings, incorporating features like indirect addressing to support larger programs by allowing instructions to reference memory locations dynamically rather than directly. This capability expanded effective addressable memory beyond the 704's constraints, facilitating more sophisticated algorithms without exhaustive code rewrites. The system's architecture prioritized floating-point arithmetic and over 180 instructions optimized for numerical analysis, reflecting lessons from 704 deployments that highlighted the need for faster, more flexible processing in government-funded projects.^[3]^[8] A pivotal innovation was the inclusion of a hardware emulator for backward compatibility with IBM 704 software, marking the first such commercial implementation to ease migration for existing users. This emulator handled registers and most 704 instructions directly in hardware, while complex operations like floating-point traps and certain I/O routines were managed via software traps, minimizing performance overhead. Development began in the mid-1950s amid IBM's push for vacuum-tube refinements, with conceptual work focusing on these compatibility mechanisms before the industry's shift to transistors influenced successors like the 7090. Announced in January 1957 and first installed in August 1958, the 709 represented a bridge within the broader IBM 700/7000 series toward more advanced computing paradigms.^[10]^[9]

Production and Installations

The IBM 709 was produced in limited numbers during a brief manufacturing run from 1958 to 1959, with over 25 installations by March 1961 primarily at U.S. research institutions and military sites, before production ended due to the rapid advancement of transistor-based computing technology, which rendered the vacuum-tube design obsolete soon after its introduction.^[8] First installations began in late summer 1958, including at General Electric, the University of California, Los Angeles (with acceptance tests in October 1958), and M.I.T. Lincoln Laboratory; other early adopters included Lockheed, Space Technology Laboratories, and Union Carbide.^[8]^[11] Operational challenges for the IBM 709 stemmed from its reliance on vacuum tubes, which demanded high maintenance, specialized air conditioning for cooling to manage heat dissipation, and stable power supplies to prevent failures from environmental factors like humidity and temperature fluctuations.^[8] Production was phased out by April 1960 as customers transitioned to the transistorized IBM 7090, which offered greater reliability and performance.^[1] Each IBM 709 system cost approximately $2.6 million in 1958 dollars, reflecting its complexity and the era's manufacturing expenses for vacuum-tube electronics.^[11]

System Architecture

Processor and Memory

The IBM 709 featured a central processing unit (CPU) based on a single-address architecture, utilizing vacuum-tube logic for its core operations. The CPU was divided into an arithmetic section responsible for performing computations and a control section that orchestrated the execution of instructions. This design supported both fixed-point and floating-point arithmetic, enabling efficient handling of scientific and engineering calculations typical of the era's applications. The arithmetic unit integrated an adder and multiplier, operating in parallel mode with synchronous timing, and employed sign-magnitude representation for fixed-point numbers, which ranged from -2^{35} + 1 to 2^{35} - 1 in 36-bit words.^[12] The memory subsystem of the IBM 709 consisted primarily of magnetic core memory, organized as a flat hierarchy with no cache and direct access from the CPU. Each word was 36 bits wide, accommodating up to 11 decimal digits or 6 BCD characters, and the system supported core memory capacities of 4,096, 8,192, or 32,768 words. The core memory operated with a cycle time of 12 microseconds, allowing for reliable nondestructive readout and rewrite operations essential for the machine's instruction execution. Optional auxiliary storage, such as magnetic drums, could extend capacity but was not part of the primary hierarchy.^[12] Addressing in the IBM 709 used a 15-bit effective address field, permitting access to the full 32,768-word memory space. This scheme facilitated direct addressing of memory locations, with support for indirect addressing through specific instruction flags that allowed the effective address to reference another memory word containing the actual target address. The control unit managed this process via a program counter that tracked the current instruction location and a fetch-execute cycle that sequentially retrieved, decoded, and performed operations, ensuring orderly program progression. Registers played a supporting role in modifying addresses during indexing, but the core addressing logic resided in the instruction format and control sequencing.^[12]

Registers

The IBM 709 featured a set of specialized registers integral to its computational and addressing capabilities. The accumulator, often referred to as the A-register, was a 38-bit register comprising a sign bit, two overflow bits (P and Q), and 35 data bits, serving as the primary storage for operands and results during arithmetic and logical operations.^[12]^[13] This design allowed the accumulator to detect and manage overflow conditions effectively, ensuring reliable fixed-point and floating-point computations.^[14] Complementing the accumulator was the multiplier/quotient register (MQ), a 36-bit register that held the multiplier during multiplication operations or the quotient during division, often extending the accumulator to form a 72-bit temporary product or facilitating quotient accumulation.^[12]^[13] The MQ also supported bit shifting and packing tasks, contributing to efficient handling of multi-word arithmetic results.^[14] For address modification, the IBM 709 included three 15-bit index registers, typically designated as X, Y, and Z (or equivalently A, B, and C in some documentation), which subtracted their contents from effective addresses to enable indexed addressing modes.^[12]^[13] These registers, addressable in octal as 1, 2, and 4, permitted logical OR combinations in instructions to select multiple indices simultaneously, supporting flexible loop control and base addressing in programs.^[14] This indexing mechanism integrated briefly with the machine's 15-bit memory addressing to modify instruction operands without altering core storage contents directly. Operator interaction and status monitoring were managed through the sense lights/indicators, four sense lights visible on the console via neon lights, that served as a communication interface for signaling conditions to the operator and detecting errors such as overflows or program halts. Complementing the console sense lights is the 36-bit sense indicator (SI) register, which programs can manipulate and test for detailed status conditions.^[15]^[13] These indicators allowed programs to set specific bits for visual feedback, with instructions enabling testing and manipulation to guide operational decisions.^[12] Finally, the program address register (PC), a 15-bit register, stored the address of the next instruction to be fetched from core memory, advancing sequentially or updating via transfer operations to control program flow.^[12]^[13] This register ensured orderly instruction sequencing within the 32,768-word address space, forming the core of the machine's control unit.^[14]

Instruction and Data Formats

The IBM 709 employed a 36-bit word length for both instructions and data, enabling efficient processing of numerical and character information. Data could be represented in fixed-point, floating-point, or alphanumeric formats. Fixed-point numbers used a sign-magnitude representation with 1 sign bit and 35 bits for the magnitude, allowing integers up to approximately $3.4 \times 10^{10}.^[16] Floating-point numbers consisted of 1 sign bit, an 8-bit exponent biased by excess-128 (range from 0 to 255, representing exponents -128 to 127), and a 27-bit fraction, providing a mantissa precision of about 8 decimal digits and a range up to roughly $10^{38}.^[16] Alphanumeric data utilized 6-bit binary-coded decimal (BCD) encoding per character, packing up to 6 characters into a single 36-bit word for text and symbolic processing.^[16] Instructions in the IBM 709 were organized into five distinct formats, each tailored to specific operation types while sharing a common 36-bit structure. Format A handled load and store operations, such as transferring data between memory and registers. Format B, the most common for arithmetic instructions with indexing support, featured a 6-bit opcode (bits 1-6), a 15-bit address field (bits 21-35), and a 9-bit field combining decrement (bits 12-17), tag (bits 18-20), and indirect indicators (bits 12-20). Format C supported no-operation variants and control transfers, often omitting full arithmetic fields for efficiency in branching. Format E managed I/O control instructions, including channel commands and device-specific operations.^[17] Addressing modes in the IBM 709 included direct addressing, where the operand location was specified outright in the instruction; indirect addressing, triggered by a special flag bit (typically bit 12 set to 1) to fetch the effective address from memory; and indexed addressing, which modified the base address by subtracting the contents of one of three index registers (X, Y, or Z, selected via 3-bit tag values 1, 2, or 4 in bits 18-20).^[17] The system supported 64 possible opcodes via the 6-bit field, enabling a repertoire of 208 basic instructions; representative examples include addition (opcode 01 octal) for fixed-point summation in the accumulator and multiplication (opcode 05 octal) for computing products using the multiplier quotient register.^[17] To facilitate operations across data types, the IBM 709 included convert instructions such as CAQ and CRQ (using Type B format) for BCD-to-binary conversion and scaling, essential for mixed-precision computations, such as scaling decimal inputs for arithmetic processing.^[17]

Input/Output System

I/O Channels

The IBM 709 featured two independent direct memory access (DMA) channels per IBM 766 Data Synchronizer, enabling overlapped input/output operations that allowed the central processing unit to continue computation while data transfers occurred independently.^[12] Up to three such synchronizers could be attached to a single system, providing a total of six channels (labeled A through F) for concurrent handling of multiple I/O units, such as magnetic tapes and card devices.^[12] This design represented the first commercial implementation of DMA channels, decoupling I/O from CPU execution to improve overall system throughput.^[14] Data transfers operated in buffered mode, where blocks of information moved directly between core memory and peripherals at speeds up to 15,000 characters per second, depending on the attached device like the IBM 729 Magnetic Tape Unit.^[12] Modes included read/write select (RDS/WRS), copy (CPY), and copy and add logical (CAD), with each channel instruction typically executing in two cycles (12 microseconds total) to initiate or manage transfers.^[14] Channel instructions followed a Type E format, incorporating an operation code, channel address, and control fields to specify actions such as starting or stopping transfers.^[14] These instructions encompassed sense and test operations, such as test I/O (TIO) and test indirect feature (TIF), for querying device status, alongside commands like input/output count and proceed (IOCP) and input/output record control and proceed (IORP) for initiating operations.^[14] Synchronization across multiple channels was managed by the data synchronizers, supporting parallel I/O from up to three units simultaneously without CPU involvement.^[12] Error handling relied on status bits within channel registers, detecting conditions like I/O checks, tape errors, end-of-file, overflow, or underflow, which could trigger program traps, skips, or halts to facilitate recovery.^[14]

Supported Peripherals

The IBM 709's I/O system supported a variety of peripheral devices for data storage, input, output, and temporary buffering, primarily connected through up to three IBM 766 data synchronizers that enabled multiple simultaneous operations.^[12]^[8] Magnetic tape served as the main high-speed storage medium, with up to 48 IBM 729 units configurable for data transfer and archival, controlled via IBM 755 tape controllers (up to 8 units per controller).^[12]^[3] These included the IBM 729-I model for the 709 and compatible 729-II variants, operating at densities of 200 or 556 characters per inch on 2,400-foot reels.^[12] For rapid-access temporary storage, the system accommodated two optional IBM 733 magnetic drum units, each holding 8,192 36-bit words across four logical drums of 2,048 words each.^[12] These drums connected directly to the CPU, bypassing synchronizers, and provided buffering for I/O operations.^[12] Input and output via punched cards utilized the IBM 711 card reader (up to 250 cards per minute) and IBM 721 card punch (100 cards per minute), with one of each attachable per synchronizer channel on channels A, C, and E.^[12] For offline data preparation, the IBM 533 card read-punch unit was employed to convert card decks to tape or process outputs independently.^[18] Printing capabilities included the online IBM 716 alphanumeric line printer (150 lines per minute, 120 characters per line), attached via synchronizer channels and powering associated card units.^[12] Higher-speed options like the IBM 1403 line printer (up to 600 lines per minute) were compatible in certain configurations for enhanced output.^[18] The system lacked native disk storage support, depending on tapes and drums for secondary storage needs, with peripherals leveraging direct memory access channels for efficient attachment.^[12]

Software and Programming

Operating Systems

The SHARE Operating System (SOS), developed collaboratively by programmers from SHARE user group installations and IBM, served as a foundational batch processing system for the IBM 709 starting in 1959.^[19]^[20] It included a resident monitor for overseeing job execution, an assembler known as SCAT for compiling symbolic programs into machine code, and various utility programs for input/output handling and debugging.^[20] Distributed through the SHARE user group via tape distributions and modification packages, SOS emphasized efficient tape-based operations to manage the era's hardware constraints.^[21]^[20] In parallel, IBM introduced IBSYS as its proprietary operating system monitor for the IBM 709 and later the 7090/7094, evolving directly from SOS to provide enhanced compatibility across configurations.^[19]^[22] IBSYS handled job sequencing through control cards and priority queuing, incorporated I/O buffering to optimize data transfer via channels, and implemented basic error recovery mechanisms to restart failed operations automatically.^[19]^[21] Both systems supported precursors to multiprogramming by overlapping I/O with computation where possible, relied on tape-based job libraries for storing and retrieving programs in compressed SQUOZE format, and facilitated operator interaction through console commands for loading jobs, pausing execution, and managing peripherals.^[19]^[20]^[21] However, they were inherently batch-oriented, lacking time-sharing capabilities due to the absence of interactive terminals and the focus on sequential job decks processed in phases—conversion, execution, and output—reflecting the hardware limitations of the late 1950s and early 1960s.^[20]^[22] SOS, in particular, exerted significant influence on subsequent IBM systems, with its design principles for monitor-based control and utility integration contributing to the development of OS/360 for the System/360 mainframes.^[19]^[23]^[21]

Programming Languages and Tools

The IBM 709 supported FORTRAN II as its primary high-level programming language, designed specifically for scientific and engineering computations. This compiler translated source code written in a mathematical notation—featuring complex arithmetic expressions, subroutine calls, and formatted input/output operations—directly into efficient machine code optimized for the system's floating-point architecture.^[24] FORTRAN II on the 709 extended the original FORTRAN I from the IBM 704 by adding support for independent compilation of subroutines and more flexible data handling, enabling programmers to develop modular programs for numerical simulations and data analysis.^[25] For low-level programming, the IBM 709 utilized the Symbolic Assembly Program (SAP), a basic assembler that allowed developers to write code using symbolic names for instructions, addresses, and constants rather than raw machine codes. SAP facilitated direct control over the 709's registers and memory, making it suitable for system-level tasks and performance-critical routines.^[13] An enhanced version, the FORTRAN Assembly Program (FAP), was introduced for the 709 and later 7090, building on SAP with additional features like macro support, relocatable code generation, and integration with FORTRAN II for mixed-language subroutines. FAP used a standardized symbolic card format (columns 1-72 for code, with room for comments) to streamline assembly into binary decks for loading.^[26] Supporting these languages were various tools, including linkers for combining object modules into executable programs and rudimentary debuggers for tracing execution via console lights and printouts. The SHARE user group, a collaborative network of IBM customers, distributed extensive libraries of pre-assembled subroutines, particularly for mathematical functions such as sine, logarithm, and matrix operations, which could be linked into FORTRAN or assembly programs to accelerate development.^[25] These SHARE libraries, often modified for 709 compatibility, provided reusable code for common algorithms, reducing the need for programmers to implement basic operations from scratch.^[27] The 709 maintained backward compatibility with the IBM 704 through an optional hardware emulator feature, which allowed direct execution of unmodified 704 assembly code and early FORTRAN I programs without recompilation. This emulator mapped 704 instructions and registers to the 709's architecture, preserving legacy software investments for users upgrading from the predecessor system.^[12] Additionally, FAP included pseudo-operations like HEAD (derived from 704-SAP) to facilitate porting of 704 source code to the 709 environment.^[26] Development on the 709 typically involved punch-card input for source code, with compilation processes reading decks via tape drives to generate object tapes or cards. Console-based debugging used operator panels to inspect memory and step through instructions, while tape-based linking assembled final programs for execution under systems like SOS.^[26] This card-and-tape workflow, supported by utilities for error checking and symbolic listing, formed the core of the 709's programming ecosystem.

Applications and Legacy

Notable Uses

The IBM 709 was employed by the U.S. Naval Ordnance Test Station at China Lake, California, for data reduction and analysis of radar and trajectory data from missile tests, including post-flight trajectory reduction of FPS-16 radar data.^[8] This installation supported real-time processing in the Assessment Division's Test Department, enabling rapid evaluation of ordnance performance critical to naval weapons development.^[8] In scientific computing, the IBM 7090 facilitated engineering simulations at General Electric's Missile and Space Vehicle Department in Philadelphia, Pennsylvania, where it handled computations for flight test data reduction, including aerodynamic analyses.^[8] At CERN, the machine arrived at the end of 1960 and was inaugurated in March 1961 as a key tool for particle physics calculations, processing experimental data from accelerators and supporting high-energy physics simulations with its vacuum-tube architecture.^[28]^[29] The system also served as a precursor in early space-related applications, such as at the U.S. Navy's Project Vanguard Computer Center, where it performed orbital calculations and processed satellite tracking data to integrate trajectories for launch missions.^[30] These efforts laid groundwork for subsequent NASA computations by demonstrating reliable numerical integration for space dynamics. At academic institutions, the IBM 709 supported advanced numerical analysis, notably in quantum theory projects at the University of Florida's Quantum Theory Project, where it executed molecular orbital calculations and energy computations for chemical physics research using programs like MBLISP.^[31]^[32] The IBM 709 was also used at the Massachusetts Institute of Technology (MIT) for early time-sharing experiments in the late 1950s and early 1960s, which pioneered multi-user computing by allowing multiple programs to share CPU time, laying the groundwork for modern operating systems.^[7] Overall, the IBM 709 enabled complex simulations previously infeasible on earlier machines, achieving up to 42,000 add or subtract operations per second to handle real-time data processing in these demanding environments.^[29]

Successors and Impact

The IBM 709's direct successors were the IBM 7090, introduced in 1959 as a transistorized version that achieved at least five times the internal processing speed of its predecessor while maintaining full program compatibility to facilitate user migration.^[33] This upgrade replaced vacuum tubes with transistors, reducing power consumption and cooling requirements by up to 70% and enabling more reliable operation for scientific computing tasks.^[33] The IBM 7094 followed in 1962, building on the 7090 with enhancements to input/output capabilities, including improved transfer instructions and support for two instructions per core storage cycle, which boosted overall system throughput by 1.4 to 2.4 times depending on the workload; it too ensured compatibility with prior 709-series software and hardware.^[34] The 709's architectural innovations laid foundational groundwork for IBM's broader computing ecosystem, particularly influencing the design of the System/360 family announced in 1964, which unified scientific and commercial processing under a single compatible architecture and extended the 700-series legacy into the mainframe era.^[35] Additionally, the machine fostered collaborative user practices through the SHARE user group, originally formed in 1955 for earlier IBM systems but actively supporting the 709 via shared operating systems like SOS, a model that promoted open exchange of software and documentation among installations and inspired later industry-wide cooperation.^[36] Technologically, the 709's introduction of direct memory access (DMA) via programmable data channels allowed independent I/O operations without CPU intervention, a precursor to modern channel architectures, while its overlapped I/O feature interleaved data transfers with computation to dramatically improve efficiency and reduce programmer burden in managing device timings.^[37]^[5] These concepts became industry standards, enhancing overall system performance in subsequent designs. The optional hardware emulator for running IBM 704 programs on the 709 further advanced software portability, a principle carried forward in later emulation efforts like the SIMH simulator, which recreates 709 functionality for historical analysis.^[38] Preservation efforts have ensured the 709's legacy endures, with at least one surviving unit donated to the Computer History Museum in 2014 by collector Paul R. Pierce, accompanied by extensive documentation including manuals and diagrams.^[39] Culturally, the 709 served as a critical bridge from the vacuum-tube era to transistor-based computing, enabling pioneering work in complex simulations and early artificial intelligence research by providing the computational power needed for such advanced endeavors during its brief but influential production run from 1958 to 1960.^[1]

References

[1]
IBM 709 - Computer History Wiki
Aug 9, 2022 · The IBM 709, announced in 1957, was IBM's last major vacuum tube scientific mainframe. It had a 36-bit word size and pioneered time-sharing.Missing: introduction date
[2]
IBM 709 Computer Information - Sky Visions
The IBM 709 was announced January 2, 1957 withdrawn April 7, 1960. Originally the IBM 709T later to be named the IBM 7090 by customers, the machine was a ...
[3]
[PDF] IBM 709
The IBM 709-outstanding new features: Increased input-output flexibility with the new Data Synchronizer. Greater input-output capacity-up to 48 tape units.Missing: specifications | Show results with:specifications
[4]
IBM 709 Data Processing System - CHM Revolution
The 709 scientific computer was compatible with the earlier 704, and offered better input/output performance. It had a short life, however: a ...Missing: specifications | Show results with:specifications
[5]
History (1958): IBM 709 - StorageNewsletter
Aug 27, 2018 · The IBM 709, introduced in 1958, was the first to use Direct Memory Access (DMA), enabling I/O to occur independently of instruction processing ...
[6]
Project Vanguard - IBM
In late summer 1955, a US Department of Defense committee announced its intention to launch the world's first artificial satellite into Earth's orbit.
[7]
Time-sharing | IBM
In the early 1960s, an experimental time-sharing system was launched at MIT on a modified IBM 709. MIT added a typewriter input so that an operator could ...Missing: date | Show results with:date<|control11|><|separator|>
[8]
[PDF] IBM 709 - Bitsavers.org
Indirect addressing plus immediate instructions are available instead of indexing. Immediate instruc- tions are standard. Indirect addressing is optional at ...
[9]
IBM 709 Data Processing System CPU - 102728984 - CHM
IBM 709 was a vacuum tube, mainframe, scientific computer introduced in 1957. It was designed to solve complex problems in commercial and scientific areas at ...
[10]
IBM Catches Up - CHM Revolution - Computer History Museum
The 709 scientific computer was compatible with the earlier 704, and offered better input/output performance. It had a short life, however: a transistor-based ...
[11]
Avoiding a Digital Dark Age | American Scientist
In the late 1950s IBM introduced the IBM 709 computer as a replacement for the older model IBM 704. The many technical improvements in the 709 made it ...
[12]
[PDF] 709·7090 Data Processing System - Bitsavers.org
The IBM 766 Data Synchronizer, used with the 709 system, provides a powerful link between core storage and the input-output devices. This new concept of.
[13]
[PDF] PROGRAMMING AND CODING THE IBM 709-7090-7094 ...
Characteristics of these computers, their repertoires of instructions, and examples of their coding appear in this booklet. A number of additional examples are ...Missing: specifications | Show results with:specifications
[14]
[PDF] 709 Data Processing System - Ibiblio
For 709 FORTRAN, the source machine must be an IBM 709 Data. Processing System which includes at least 8, 192 storage locations,. 5 tape units, 1 on-line card ...
[15]
Reference Manual - IBM 7090 Data Processing System
functions of major registers and counters within the. CPU. The accumulator register ... portion of the instruction is interpreted in the sr. Three index registers.Missing: architecture PC
[16]
http://bitsavers.org/pdf/ibm/7090/D22-6508-2_709_7090_General_Information_Manual_Aug1960.pdf
[17]
[PDF] Reference Manual IBM 7090 Data Processing System - Bitsavers.org
The principal changes are the addition of Hypertape Drive information and added 7909 Data Channel information. Newsletters N22-0014 and. N22-0019 are obsoleted ...Missing: phased | Show results with:phased
[18]
IBM 533 Card reader/ punch - 102728144 - Computer History Museum
There are 14 control buttons along the middle front edge and a plastic badge which says, "IBM read punch." Below the badge is a card opening with punch cards ...Missing: 709 | Show results with:709
[19]
First-Hand:Operating System Roots
Jan 12, 2015 · A team of programmers from SHARE installations and IBM built a new operating system for the 709. It was called SOS (SHARE Operating System).
[20]
http://bitsavers.org/pdf/ibm/share/SOS_Reference_Manual_Jun61.pdf
[21]
The Direct Couple for the IBM 7090 - Software Preservation Group
IBSYS was an operating system for the 7090 that evolved from SOS (SHARE Operating System) for the 709 which evolved from the GM-NAA I-O System (General Motors - ...Missing: synchronizers Hockney<|control11|><|separator|>
[22]
IBM s early operating systems for 1410, 7090, and S/360
The SHARE Operating System, also known as SOS, was created in 1959 as an improvement on the General Motors GM-NAA I/O operating system, the first operating ...
[23]
Paul Pierce – Dusty Decks: Preserving historic software - McJones
Mar 19, 2004 · Another very important early bit of software is the MockDonald system, which evolved into SOS, then IBSYS, and was a big influence on OS/360.<|control11|><|separator|>
[24]
[PDF] Reference Manual 709/7090 Fortran Programming System
The FORTRAN language provides facilities for expressing any problem of numerical computation. In particular, problems con- taining large sets of formulas and ...
[25]
[PDF] Systems Manual for 704 and 709 Fortran - Bitsavers.org
This manual is an attempt to fulfill a long standing, much-pressed request. That is, a request for an over-all, comprehensive explan-.
[26]
[PDF] FORTRAN ASSEMBLY PROGRAM (FAP) for the IBM 709/7090
Elements of. FAP"is a fast, versatile, general purpose assembler for the IBM 709/7090 the Language written expressly for use within the IBM 709 FORTRAN Monitor.
[27]
[PDF] Catalog of Programs for IBM 704-709-7040-7044-7090 and 7094 ...
This Catalog contains a complete listing of all programs available for the IBM 704, 709, 7040,. 7044, 7090, and 7094 Data Processing Systems. It obsoletes all ...
[28]
Computing at CERN: the mainframe era
Sep 5, 2004 · ... a processing power 10 times that of the IBM 7090. With serial ... With a speed of just over 10 Mips (millions of instructions per second) ...<|separator|>
[29]
CERN inaugurates the IBM 709 | timeline.web.cern.ch
The IBM 709 was inaugurated at CERN on March 6, 1961, and ran from 1961 to 1963. It had 32K core memory and a faster CPU than Mercury.Missing: history date
[30]
[PDF] The IBM System/360
Apr 24, 2024 · • An optional hardware emulator executed 704 programs. Page 49. Real Time Computer Center. (RTCC): Project Mercury. © 2024 IBM Corporation. 49.
[31]
[PDF] , by Quantum Theory Project - NASA Technical Reports Server (NTRS)
The entire calculation was done on the IBM 709 at the University. Upper Bound energies were first obtained by of Florida Computing Center. the Rayleigh-Ritz ...
[32]
[PDF] An IBM 709/7090 Operator's Manual for MBLISP
Once the count has reached 77777, a garbage collection will be initiated, during which time sense light I is lit, and the sign bits are lit. Currently, garbage ...
[33]
[PDF] 7090 data processing system
The 7090's internal processing speed is at least five times faster than that of the 709. The 7090 uses a maximum of eight input-output data channels.
[34]
How IBM 7094 Gave NASA Computing Superiority in the 1960s
Oct 11, 2016 · NASA and the Air Force used the 7094 for critical operations, and the mainframe played a large role in the Gemini and Apollo space program, as ...<|control11|><|separator|>
[35]
IBM 700 Series
which, for the first time, featured transistors instead of vacuum tubes.
[36]
The share operating system for the IBM 709 - ScienceDirect.com
The Share Operating System for the IBM 709 represents an important advance in the art of machine usage. A single symbolic language is used for all ...
[37]
IBM 709
The 709 was a 36-bit binary machine very similar to the 704. It added data channels instead of programmed I/O. The data channels were programmable DMA units ...
[38]
Simulators – Dusty Decks: Preserving historic software - McJones
An upcoming release of Bob Supnik's SIMH (Computer History Simulation system) will include IBM 704/709/7090/7094 simulation provided by Rich Cornwell. Rich ...Whetstone Algol · Ibsys Fortran Ii Runs On A... · Pascal Bourguignon Recreates...
[39]
Paul R. Pierce collection of IBM documentation - 102784976 - CHM
In 2014, Pierce donated an IBM 709, IBM 7094, IBM 650, and several other machines from his collection, as well as their accompanying documentation, to the ...Missing: emulator | Show results with:emulator