The $5 Billion Gamble: How the IBM System/360 Bet the Company

On April 7, 1964, International Business Machines announced a family of six computers called System/360. The company's chairman, Thomas J. Watson Jr., later described the announcement as the most important product launch in IBM's history. It was also a gamble. To build the family, IBM spent a sum that business writers put at five billion dollars, at a time when the company's yearly revenue was a little over three billion. If customers had refused to buy, IBM would have been in serious trouble.

The gamble succeeded. System/360 set the pattern for mainframe computers for decades, fixed the 8-bit byte as the basic unit of computer memory, and taught the industry a painful lesson about the cost of large software projects. This deep dive explains what IBM changed, why it was so risky and what it left behind.

A company with too many computers

By the early 1960s IBM dominated the business of computing. It had grown by selling machines to banks, insurers, manufacturers and governments. But the company's success had produced a problem. IBM sold several families of computers, and they were not compatible with each other.

The small, popular IBM 1401 served businesses that wanted to process payroll and accounts. The IBM 7090 and its relatives served scientists and engineers who needed fast arithmetic. Other lines served other markets. Each family had its own instruction set, its own memory layout, its own input and output devices and its own software. A program written for one would not run on another.

That arrangement hurt customers. A company that outgrew its 1401 could buy a larger machine from IBM, but it had to rewrite its programs, retrain its staff and convert its data. The cost of switching was large enough that some customers considered moving to a competitor at the same time. IBM also paid a price. It had to design, build, document and support many unrelated products, each with its own software team.

The plan: one family

In late 1961 IBM set up a task force known as SPREAD, short for Systems Programming, Research, Engineering and Development. Its job was to propose a new product strategy. The group's report argued for a bold step: replace the existing lines with a single family of compatible machines that covered the whole range from small to large.

The idea was simple to state and extremely hard to carry out. Every model, from the cheapest to the most powerful, would run the same programs. A customer could start with a small machine and move up to a larger one without rewriting anything. The same disk drives, tape drives and printers would work with every model. IBM would sell the whole family as one product line.

The name reflected the ambition. System/360 referred to the full circle of the compass, meaning that the family would serve every kind of customer, scientific as well as commercial. Earlier computers had usually been built for one or the other.

The people

Several leaders shaped the project. Thomas Watson Jr. approved it and took the financial risk. Vincent Learson, a senior executive, pushed it forward within the company. Bob Evans directed engineering and became one of the central managers. Gene Amdahl served as the chief architect in the early stage, and Gerrit Blaauw worked with him on the architecture. Fred Brooks led the development of the hardware and then of the operating system. Together, Amdahl, Blaauw and Brooks wrote a paper in 1964 that described the architecture of the family.

That paper gave computing a lasting term. It defined "architecture" as the structure of the machine as the programmer sees it, kept apart from the way the machine is built inside. Under this idea, a program depends on the architecture, and engineers are free to change the implementation. The distinction is now so familiar that it is hard to see how new it was.

The size of the bet

Developing the family required enormous investment. IBM built new factories, hired thousands of engineers and programmers and ran several design efforts at once. The company drew on its profits and borrowed money. Fortune magazine, writing in 1966, called the effort "IBM's $5,000,000,000 gamble." Watson later wrote that the project was the biggest investment in the company's history.

To grasp the risk, consider the timing. If the new machines had been late or unreliable, customers might have switched to competitors. If the machines had been compatible but slow, buyers might have kept their old equipment. IBM was replacing a successful business with an unproven one, and it was doing so while its competitors were free to attack.

How compatibility worked

The central technical problem was how to make machines of very different sizes behave the same way. A small, cheap model needs simple circuits, and a large, fast model needs complex ones. Yet both had to execute the same instructions.

IBM solved the problem with microcode, a technique that had been described by the British scientist Maurice Wilkes in 1951 and was used here on a large scale. In a microcoded machine, each program instruction is carried out by a small built-in program. On a small model, a complicated instruction was broken into many simple steps. On a large model, the same instruction was done mostly in dedicated circuitry. The programmer saw the same result in both cases, though the faster model got there sooner.

Microcode also helped customers move. IBM provided emulation features, built from microcode, that let the new machines run programs written for the old ones, such as the 1401. Customers could switch to System/360 right away and convert their software at their own pace.

The byte

Before System/360, computers used a mixture of word sizes. Some machines used 36-bit words, some 48 and some 12. Many stored characters in six bits, which was enough for capital letters, digits and a few symbols but not for lowercase letters. The term "byte" had been coined in the 1950s by Werner Buchholz, an IBM engineer, for a group of bits that held one character.

System/360 made the byte eight bits wide, and addressed memory by the byte. Eight bits can represent 256 different values, enough for upper and lowercase letters, digits, punctuation and control codes. IBM's machines also grouped bytes into larger units, such as 32-bit words and 64-bit double words. The choice spread with the success of the family. Almost every computer since then, including the ones in phones and laptops, counts memory in 8-bit bytes. System/360 was not the only influence, but it was the most important one.

Not every decision aged well. IBM also introduced a character code called EBCDIC, which differed from the ASCII code used by much of the rest of the industry. The difference caused conversion headaches for years.

Hybrid circuits

The machines used a technology IBM called Solid Logic Technology. The circuits were small modules in which transistors and other parts were formed on tiny ceramic squares and then connected together. They were smaller and more reliable than the older circuit boards, but they were not integrated circuits of the kind that would soon take over. IBM's choice has been debated. Integrated circuits were still new, and IBM judged that it could not buy enough of them or rely on them for a product of this scale. The company could manufacture its own hybrid modules in volume.

Beyond the processor

Compatibility reached past the central processor. IBM defined a standard way for devices to connect to the computer, using units called channels that handled the transfer of data to and from tape drives, disk drives, printers and card readers. A customer could attach the same peripherals to a small or large model. IBM announced a large range of devices with the family, and customers who grew could keep what they had bought.

IBM also leased most of its machines in those years, which lowered the cost of entry for customers. The company earned steady income from rentals and from sales of the peripheral equipment. That business model helped to pay for the huge investment, and it gave IBM a strong reason to keep its customers happy.

The high end

The largest machines pushed the technology further. The Model 91, announced in 1964 and delivered in 1967, was built for scientific work and competed with the fastest supercomputers of its day. Its designers introduced methods for doing several instructions at once, including an algorithm by Robert Tomasulo that lets a processor schedule work out of order. Ideas of this kind appear in modern processors. The Model 91 showed that the same architecture could reach from small business machines to the fastest scientific computing.

Reception

The market's response was strong. Orders poured in during the first weeks. IBM reported that it had taken in more than a thousand orders in the first month, far above expectations. The company struggled to build machines fast enough to meet demand. For several years customers waited for delivery.

Competitors responded in different ways. Some, such as Honeywell, built machines that ran IBM software at lower prices. Others aimed at niches that IBM did not serve well. A few firms, including Control Data, concentrated on the top end, where speed mattered most. Gene Amdahl left IBM in 1970 and founded his own company, which sold computers that ran IBM software.

What it meant for the people who used it

For operators, the machines brought a new daily routine. Programs were still prepared on punched cards and run in batches, and results came back as printed pages. A job control language told the operating system which programs to run and which files to use. The language was notoriously fussy, and generations of programmers remember its strict syntax with mixed feelings.

For managers, the family changed planning. A company could now treat its computer as a long-term asset instead of a short-term tool, and could budget for growth. Staff who specialized in the machines formed a new profession, with job titles such as systems programmer and operator. The mainframe data center became a feature of large organizations.

For students, the machines were often the first computers they met. Many programmers of the next two decades learned on a System/360 or one of its relatives, writing in FORTRAN, COBOL or assembly language, and carrying card decks to the computer center. Their habits shaped the culture of the field.

The software crisis

The hardware shipped, and the software did not keep up. An operating system is the program that manages a computer's memory, storage and tasks. For a family of machines that ranged from tiny to huge, IBM planned OS/360, a single operating system that would work on all of them and support many features.

The project proved far harder than expected. The system had millions of instructions and thousands of parts that had to fit together. The schedule slipped repeatedly, and early versions were slow and filled with errors. At its peak the effort involved over a thousand people. IBM released simpler versions of the software so that customers could keep working, but the full system arrived years behind plan.

Brooks's lessons

Fred Brooks took charge of the OS/360 effort after the early design work, and he lived through the troubles. Afterward he left IBM to found the computer science department at the University of North Carolina at Chapel Hill. In 1975 he published The Mythical Man-Month, a collection of essays on what he had learned. The book remains one of the most widely read works on software management.

Its best-known idea is now called Brooks's law: adding people to a late software project makes it later. New people must be taught, and the more people there are, the more time is spent in communication. If ten people must coordinate, the number of connections between them is far larger than for three. Brooks also argued that the unit of "man-months," which treats people and time as interchangeable, was a myth for tasks that cannot be split up neatly.

Other lessons from the book became part of the field's vocabulary. The "second-system effect" warns that a designer's second project tends to be bloated, because the designer adds every idea that was left out of the first. The "surgical team" proposes that a large programming job be organized around one chief programmer with specialized helpers, in place of a crowd of equals. The book also stressed the need to keep the design coherent, and said that the best designs come from a small number of minds.

The family grows and endures

System/360 was followed by System/370 in 1970, which added virtual memory, and by later generations. The architecture continued through System/390 and into the zSeries and the IBM Z machines of today. A large share of the world's banking transactions, airline reservations and insurance records still pass through such machines.

Compatibility has been kept at a remarkable level. Many programs written in the 1960s can run on today's mainframes with little or no change. Few other computer designs have lasted so long. The commitment to protect customers' investment in software, which began with the 1964 announcement, became the foundation of IBM's business for decades.

System/360 machines also appeared in places that showed their reach. Airlines moved their reservation systems to the family. Universities used them for teaching and research. NASA used System/360 computers in the Houston control center during the Apollo program. Banks bought them for check processing, and governments for tax and census work.

Why it still matters

Three lessons from System/360 apply well beyond mainframes. The first is the value of a stable interface. When the architecture was fixed, customers and programmers could plan for the long term, and the hardware behind it could improve. Modern software relies on the same bargain when it offers programming interfaces that stay the same as the machines underneath them change.

The second lesson is that standards help everyone. The 8-bit byte made it easier to exchange data and to design devices. The third lesson is about the cost of complexity. Brooks's account of OS/360 gave software engineers a shared story about why large projects fail, and how modest, careful planning can improve their chances.

For a museum visitor, a System/360 console may look like a wall of lights and switches. Behind the panel was a quiet revolution in how businesses thought about computers: as a family of tools that could grow with the customer. That idea still shapes how people buy and build technology.

Questions for reflection

• IBM risked its main business to build a new, compatible family. When is it worth giving up something that works?
• Why might a standard such as the 8-bit byte help a whole industry even if it was chosen by a single company?
• Brooks said that adding people to a late project makes it later. Can you think of a team project of your own where that was true?