History of computing hardware (1960s–present)

For the purposes of this article, the term "second generation" refers to computers using discrete transistors, even when the vendors referred to them as "third-generation". By 1960 transistorized computers were replacing vacuum tube computers, offering lower cost, higher speeds, and reduced power consumption. The marketplace was dominated by IBM and the seven dwarfs:

• IBM
• The BUNCH
  • Burroughs
  • UNIVAC
  • NCR
  • Control Data Corporation (CDC)
  • Honeywell
• General Electric
• RCA.

Some examples of 1960s second generation computers from those vendors are:

• the IBM 1401, the IBM 7090/7094, and the IBM System/360;
• the Burroughs 5000 series;
• the UNIVAC 1107;
• the NCR 315;
• the CDC 1604 and the CDC 3000 series;
• the Honeywell 200, Honeywell 400, and Honeywell 800;
• the GE-400 series and the GE-600 series;
• the RCA 301, 3301 and the Spectra 70 series.

However, some smaller companies made significant contributions. Also, towards the end of the second generation Digital Equipment Corporation (DEC) was a serious contender in the small and medium machine marketplace.

Meanwhile, second-generation computers were also being developed in the USSR as, e.g., the Razdan family of general-purpose digital computers created at the Yerevan Computer Research and Development Institute.

The second-generation computer architectures initially varied; they included character-based decimal computers, sign-magnitude decimal computers with a 10-digit word, sign-magnitude binary computers, and ones' complement binary computers, although Philco, RCA, and Honeywell, for example, had some computers that were character-based binary computers and Digital Equipment Corporation (DEC) and Philco, for example, had two's complement computers. With the advent of the IBM System/360, two's complement became the norm for new product lines.

The most common word sizes for binary mainframes were 36 and 48 bits, although entry-level and midrange machines used smaller words, e.g., 12 bits, 18 bits, 24 bits, 30 bits. All but the smallest machines had asynchronous I/O channels and interrupts. Typically binary computers with word size up to 36 bits had one instruction per word, binary computers with 48 bits per word had two instructions per word and the CDC 60-bit machines could have two, three, or four instructions per word, depending on the instruction mix; the Burroughs B5000, B6500/B7500 and B8500 lines are notable exceptions to this.

First-generation computers with data channels (I/O channels) had a basic DMA interface to the channel cable. The second generation saw both simpler, e.g., channels on the CDC 6000 series had no DMA, and more sophisticated designs, e.g., the 7909 on the IBM 7090 had limited computational, conditional branching and interrupt system.

By 1960, magnetic core was the dominant memory technology, although there were still some new machines using drums and delay lines during the 1960s. Magnetic thin film and rod memory were used on some second-generation machines, but advances in core technology meant they remained niche players until semiconductor memory displaced both core and thin film.

In the first generation, word-oriented computers typically had a single accumulator and an extension, referred to as, e.g., Upper and Lower Accumulator, Accumulator and Multiplier-Quotient (MQ) register. In the second generation, it became common for computers to have multiple addressable accumulators. On some computers, e.g., PDP-6, the same registers served as accumulators and index registers, making them an early example of general-purpose registers.

In the second generation there was considerable development of new address modes, including truncated addressing on, e.g., the Philco TRANSAC S-2000, the UNIVAC III, and automatic index register incrementing on, e.g., the RCA 601, UNIVAC 1107, and the GE-600 series. Although index registers were introduced in the first generation under the name B-line, their use became much more common in the second generation. Similarly, indirect addressing became more common in the second generation, either in conjunction with index registers or instead of them. While first-generation computers typically had a small number of index registers or none, several lines of second-generation computers had large numbers of index registers, e.g., Atlas, Bendix G-20, IBM 7070.

The first generation had pioneered the use of special facilities for calling subroutines, e.g., TSX on the IBM 709. In the second generation, such facilities were ubiquitous. In the descriptions below, NSI is the next sequential instruction, the return address. Some examples are:

Automatically record the NSI in a register for all or most successful branch instructions

The Jump Address (JA) Register on the Philco TRANSAC S-2000

The Sequence History (SH) and Cosequence History (CSH) registers on the Honeywell 800

The B register on an IBM 1401 with the indexing feature

Automatically record the NSI at a standard memory location following all or most successful branches

Store P (STP) locations on RCA 301 and RCA 501

Call instructions that save the NSI in the first word of the subroutine

Return Jump (RJ) on the UNIVAC 1107

Return Jump (RJ) on CDC 3600 and CDC 6000 series

Call instructions that save the NSI in an implicit or explicit register

Branch and Load Location in Index Word (BLX) on the IBM 7070

Transfer and Set Xn (TSXn) on the GE-600 series

Branch and Link (BAL) on the IBM System/360

Call instructions that use an index register as a stack pointer and push return information onto the stack

Push jump (PUSHJ) on the DEC PDP-6

Implicit call with return information pushed onto the stack

Program descriptors on the Burroughs B5000 line

Program descriptors on the Burroughs B6500 line

The second generation saw the introduction of features intended to support multiprogramming and multiprocessor configurations, including master/slave (supervisor/problem) mode, storage protection keys, limit registers, protection associated with address translation, and atomic instructions.

The mass increase in the use of computers accelerated with 'Third Generation' computers starting around 1966 in the commercial market. These generally relied on early (sub-1000 transistor) integrated circuit technology. The third generation ends with the microprocessor-based fourth generation.

In 1958, Jack Kilby at Texas Instruments invented the hybrid integrated circuit (hybrid IC),[1] which had external wire connections, making it difficult to mass-produce.[2] In 1959, Robert Noyce at Fairchild Semiconductor invented the monolithic integrated circuit (IC) chip.[3][2] It was made of silicon, whereas Kilby's chip was made of germanium. The basis for Noyce's monolithic IC was Fairchild's planar process, which allowed integrated circuits to be laid out using the same principles as those of printed circuits. The planar process was developed by Noyce's colleague Jean Hoerni in early 1959, based on the silicon surface passivation and thermal oxidation processes developed by Mohamed M. Atalla at Bell Labs in the late 1950s.[4][5][6]

Computers using IC chips began to appear in the early 1960s. For example, the 1961 Semiconductor Network Computer (Molecular Electronic Computer, Mol-E-Com),[7][8][9] the first monolithic integrated circuit[10][11][12] general purpose computer (built for demonstration purposes, programmed to simulate a desk calculator) was built by Texas Instruments for the US Air Force.[13][14][15][16]

Some of their early uses were in embedded systems, notably used by NASA for the Apollo Guidance Computer, by the military in the LGM-30 Minuteman intercontinental ballistic missile, the Honeywell ALERT airborne computer,[17][18] and in the Central Air Data Computer used for flight control in the US Navy's F-14A Tomcat fighter jet.

An early commercial use was the 1965 SDS 92.[19][20] IBM first used ICs in computers for the logic of the System/360 Model 85 shipped in 1969 and then made extensive use of ICs in its System/370 which began shipment in 1971.

The integrated circuit enabled the development of much smaller computers. The minicomputer was a significant innovation in the 1960s and 1970s. It brought computing power to more people, not only through more convenient physical size but also through broadening the computer vendor field. Digital Equipment Corporation became the number two computer company behind IBM with their popular PDP and VAX computer systems. Smaller, affordable hardware also brought about the development of important new operating systems such as Unix.

1969: Data General Nova

In November 1966, Hewlett-Packard introduced the 2116A[21][22] minicomputer, one of the first commercial 16-bit computers. It used CTµL (Complementary Transistor MicroLogic)[23] in integrated circuits from Fairchild Semiconductor. Hewlett-Packard followed this with similar 16-bit computers, such as the 2115A in 1967,[24] the 2114A in 1968,[25] and others.

In 1969, Data General introduced the Nova and shipped a total of 50,000 at $8,000 each. The popularity of 16-bit computers, such as the Hewlett-Packard 21xx series and the Data General Nova, led the way toward word lengths that were multiples of the 8-bit byte. The Nova was first to employ medium-scale integration (MSI) circuits from Fairchild Semiconductor, with subsequent models using large-scale integrated (LSI) circuits. Also notable was that the entire central processor was contained on one 15-inch printed circuit board.

Large mainframe computers used ICs to increase storage and processing abilities. The 1965 IBM System/360 mainframe computer family are sometimes called third-generation computers; however, their logic consisted primarily of SLT hybrid circuits, which contained discrete transistors and diodes interconnected on a substrate with printed wires and printed passive components; the S/360 M85 and M91 did use ICs for some of their circuits. IBM's 1971 System/370 used ICs for their logic, and later models used semiconductor memory.

By 1971, the ILLIAC IV supercomputer was the fastest computer in the world, using about a quarter-million small-scale ECL logic gate integrated circuits to make up sixty-four parallel data processors.[26]

Third-generation computers were offered well into the 1990s; for example the IBM ES9000 9X2 announced April 1994[27] used 5,960 ECL chips to make a 10-way processor.[28] Other third-generation computers offered in the 1990s included the DEC VAX 9000 (1989), built from ECL gate arrays and custom chips,[29] and the Cray T90 (1995).

Third-generation minicomputers were essentially scaled-down versions of mainframe computers, whereas the fourth generation's origins are fundamentally different. The basis of the fourth generation is the microprocessor, a computer processor contained on a single large-scale integration (LSI) MOS integrated circuit chip.[30]

Microprocessor-based computers were originally very limited in their computational ability and speed and were in no way an attempt to downsize the minicomputer. They were addressing an entirely different market.

Processing power and storage capacities have grown beyond all recognition since the 1970s, but the underlying technology has remained basically the same of large-scale integration (LSI) or very-large-scale integration (VLSI) microchips, so it is widely regarded that most of today's computers still belong to the fourth generation.

Microprocessors

1971: Intel 4004

The microprocessor has origins in the MOS integrated circuit (MOS IC) chip.[30] The MOS IC was fabricated by Fred Heiman and Steven Hofstein at RCA in 1962.[31] Due to rapid MOSFET scaling, MOS IC chips rapidly increased in complexity at a rate predicted by Moore's law, leading to large-scale integration (LSI) with hundreds of transistors on a single MOS chip by the late 1960s. The application of MOS LSI chips to computing was the basis for the first microprocessors, as engineers began recognizing that a complete computer processor could be contained on a single MOS LSI chip.[30]

The earliest multi-chip microprocessors were the Four-Phase Systems AL1 in 1969 and Garrett AiResearch MP944 in 1970, each using several MOS LSI chips.[30] On November 15, 1971, Intel released the world's first single-chip microprocessor, the 4004, on a single MOS LSI chip. Its development was led by Federico Faggin, using silicon-gate MOS technology, along with Ted Hoff, Stanley Mazor and Masatoshi Shima.[32] It was developed for a Japanese calculator company called Busicom as an alternative to hardwired circuitry, but computers were developed around it, with much of their processing abilities provided by one small microprocessor chip. The dynamic RAM (DRAM) chip was based on the MOS DRAM memory cell developed by Robert Dennard of IBM, offering kilobits of memory on one chip. Intel coupled the RAM chip with the microprocessor, allowing fourth generation computers to be smaller and faster than prior computers. The 4004 was only capable of 60,000 instructions per second, but its successors brought ever-growing speed and power to computers, including the Intel 8008, 8080 (used in many computers using the CP/M operating system), and the 8086/8088 family. (The IBM personal computer (PC) and compatibles use processors that are still backward-compatible with the 8086.) Other producers also made microprocessors which were widely used in microcomputers.

The following table shows a timeline of significant microprocessor development.

Year	Microprocessors
1969	Four-Phase Systems AL1
1971	Intel 4004
1972	Fairchild PPS-25; Intel 8008; Rockwell PPS-4
1973	Burroughs Mini-D; National Semiconductor IMP-16; NEC µCOM
1974	General Instrument CP1600; Intel 4040, 8080; Mostek 5065; Motorola 6800; National Semiconductor IMP-4, IMP-8, ISP-8A/500, PACE; Texas Instruments TMS 1000; Toshiba TLCS-12
1975	Fairchild F8; Hewlett Packard BPC; Intersil 6100; MOS Technology 6502; RCA CDP 1801; Rockwell PPS-8; Signetics 2650; Western Digital MCP-1600
1976	RCA CDP 1802; Signetics 8X300; Texas Instruments TMS9900; Zilog Z80
1977	Intel 8085
1978	Intel 8086; Motorola 6801, 6809
1979	Intel 8088; Motorola 68000; Zilog Z8000
1980	National Semiconductor 16032; Intel 8087
1981	DEC T11; Harris 6120; IBM ROMP
1982	Hewlett-Packard FOCUS; Intel 80186, 80188, 80286; DEC J-11; Berkeley RISC-I
1983	Stanford MIPS; Berkeley RISC-II
1984	Motorola 68020; National Semiconductor 32032; NEC V20
1985	DEC MicroVAX 78032/78132; Harris Novix; Intel 80386; MIPS R2000
1986	NEC V60; Sun SPARC MB86900/86910; Zilog Z80000
1987	Acorn ARM2; DEC CVAX 78034; Hitachi Gmicro/200; Motorola 68030; NEC V70
1988	Apollo PRISM; Intel 80386SX, i960; MIPS R3000
1989	DEC VAX DC520 Rigel; Intel 80486, i860
1990	IBM POWER1; Motorola 68040
1991	DEC NVAX; IBM RSC; MIPS R4000
1992	DEC Alpha 21064; Hewlett-Packard PA-7100; Sun microSPARC I
1993	IBM POWER2, PowerPC 601; Intel Pentium; Hitachi SuperH
1994	DEC Alpha 21064A; Hewlett-Packard PA-7100LC, PA-7200; IBM PowerPC 603, PowerPC 604, ESA/390 G1; Motorola 68060; QED R4600; NEC V850
1995	DEC Alpha 21164; HAL Computer SPARC64; Intel Pentium Pro; Sun UltraSPARC; IBM ESA/390 G2
1996	AMD K5; DEC Alpha 21164A; HAL Computer SPARC64 II; Hewlett Packard PA-8000; IBM P2SC, ESA/390 G3; MTI R10000; QED R5000
1997	AMD K6; IBM PowerPC 620, PowerPC 750, RS64, ESA/390 G4; Intel Pentium II; Sun UltraSPARC IIs
1998	DEC Alpha 21264; HAL Computer SPARC64 III; Hewlett Packard PA-8500; IBM POWER3, RS64-II, ESA/390 G5; QED RM7000; SGI MIPS R12000
1999	AMD Athlon; IBM RS64-III; Intel Pentium III; Motorola PowerPC 7400
2000	AMD Athlon XP, Duron; Fujitsu SPARC64 IV; IBM RS64-IV, z900; Intel Pentium 4
2001	IBM POWER4; Intel Itanium; Motorola PowerPC 7450; SGI MIPS R14000; Sun UltraSPARC III
2002	Fujitsu SPARC64 V; Intel Itanium 2
2003	AMD Opteron, Athlon 64; IBM PowerPC 970; Intel Pentium M
2004	IBM POWER5, PowerPC BGL
2005	AMD Athlon 64 X2, Opteron Athens; IBM PowerPC 970MP, Xenon; Intel Pentium D; Sun UltraSPARC IV, UltraSPARC T1
2006	IBM Cell/B.E., z9; Intel Core 2, Core Duo, Itanium Montecito
2007	AMD Opteron Barcelona; Fujitsu SPARC64 VI; IBM POWER6, PowerPC BGP; Sun UltraSPARC T2; Tilera TILE64
2008	AMD Opteron Shanghai, Phenom; Fujitsu SPARC64 VII; IBM PowerXCell 8i, z10; Intel Atom, Core i7; Tilera TILEPro64
2009	AMD Opteron Istanbul, Phenom II
2010	AMD Opteron Magny-cours; Fujitsu SPARC64 VII+; IBM POWER7, z196; Intel Itanium Tukwila, Westmere, Nehalem-EX; Sun SPARC T3
2011	AMD FX Bulldozer, Interlagos, Llano; Fujitsu SPARC64 VIIIfx; Freescale PowerPC e6500; Intel Sandy Bridge, Xeon E7; Oracle SPARC T4
2012	Fujitsu SPARC64 IXfx; IBM POWER7+, zEC12; Intel Itanium Poulson; Apple A6
2013	Fujitsu SPARC64 X; Intel Haswell; Oracle SPARC T5
2014	IBM POWER8
2015	IBM z13
2017	IBM POWER9, z14; AMD Ryzen
2020	Apple M1

Supercomputers

Main article: History of supercomputing

1976: Cray-1 supercomputer

The powerful supercomputers of the era were at the other end of the computing spectrum from the microcomputers, and they also used integrated circuit technology. In 1976, the Cray-1 was developed by Seymour Cray, who had left Control Data in 1972 to form his own company. This machine was the first supercomputer to make vector processing practical. It had a characteristic horseshoe shape to speed processing by shortening circuit paths. Vector processing uses one instruction to perform the same operation on many arguments; it has been a fundamental supercomputer processing method ever since. The Cray-1 could calculate 150 million floating-point operations per second (150 megaflops). 85 were shipped at a price of $5 million each. The Cray-1 had a CPU that was mostly constructed of SSI and MSI ECL ICs.

Time-sharing computer terminals connected to central computers, such as the TeleVideo ASCII character mode smart terminal pictured here, were sometimes used before the advent of the PC.

Computers were generally large, costly systems owned by large institutions before the introduction of the microprocessor in the early 1970s—corporations, universities, government agencies, and the like. Users were experienced specialists who did not usually interact with the machine itself, but instead prepared tasks for the computer on off-line equipment, such as card punches. A number of assignments for the computer would be gathered up and processed in batch mode. After the jobs had completed, users could collect the output printouts and punched cards. In some organizations, it could take hours or days between submitting a job to the computing center and receiving the output.

A more interactive form of computer use developed commercially by the middle 1960s. In a time-sharing system, multiple teleprinter and display terminals let many people share the use of one mainframe computer processor, with the operating system assigning time slices to each user's jobs. This was common in business applications and in science and engineering.

A different model of computer use was foreshadowed by the way in which early, pre-commercial, experimental computers were used, where one user had exclusive use of a processor.[33] Some of the first computers that might be called "personal" were early minicomputers such as the LINC and PDP-8, and later on VAX and larger minicomputers from Digital Equipment Corporation (DEC), Data General, Prime Computer, and others. They originated as peripheral processors for mainframe computers, taking on some routine tasks and freeing the processor for computation.

By today's standards, they were physically large (about the size of a refrigerator) and costly (typically tens of thousands of US dollars), and thus were rarely purchased by individuals. However, they were much smaller, less expensive, and generally simpler to operate than the mainframe computers of the time, and thus affordable by individual laboratories and research projects. Minicomputers largely freed these organizations from the batch processing and bureaucracy of a commercial or university computing center.

In addition, minicomputers were more interactive than mainframes, and soon had their own operating systems. The minicomputer Xerox Alto (1973) was a landmark step in the development of personal computers, because of its graphical user interface, bit-mapped high-resolution screen, large internal and external memory storage, mouse, and special software.[34]

• History of computing hardware, before the 1960s
• Influence of the IBM PC on the personal computer market
• Timeline of computing
• History of Computer Software
• CPU design, a technical discussion of computing history
• History of operating systems
• History of the Internet
• History of the graphical user interface
• Timeline of programming languages
• Hardware description language
• Hardware abstraction layer
• Computer architecture, how computers are designed
• List of fictional computers
• Fifth generation computer
• Quantum computing
• Curta calculator
• List of pioneers in computer science
• Pirates of Silicon Valley, docudrama about Apple Inc. and Microsoft's early days
• Triumph of the Nerds
• Ubiquitous computing
• Internet of things
• Fog computing
• Edge computing
• Ambient intelligence
• System on a chip
• Network on a chip

• Freiberger, Paul; Swaine, Michael (2000) [1984]. Fire in the Valley: The Making of the Personal Computer (2nd ed.). New York: McGraw-Hill. ISBN 0-07-135892-7.

• Stephen White's Computer history site (the above article is a modified version of his work, used with permission)
• Digital Deli, edited by Steve Ditlea, full text of the classic computer book
• Collection of old analog and digital computers at Old Computer Museum
• ZX81 Computer Online Museum
• Yahoo Computers and History
• IEEE computer history timeline (Archive from 2005)
• Links to all things Commodore
• A homebrew computer club site
• Computer History Museum
• Pictures and information on old computers
• PowerSource Online: New, Used, Refurbished, Hard to Find Parts, Equipment & Services
• History of Computers (1989–2004) in PC World excerpts
• How It Works – The Computer, 1971 and 1979 editions, by David Carey, illustrated by B. H. Robinson
• PC History Stan Veit's classic work on the history of Pre-IBM personal computers.
• WWW-VL: Internet History