Source: Byte, September 1990
Author: David J. Bradley
Based on this HTML version.
Style and minor corrections by Tomáš Slavotínek.
In August 1980, I had finished my work on what was to become the IBM System/23
DataMaster. The DataMaster was an Intel 8085-based system intended to run business
applications written in BASIC. I had written some of the device-control code for
that system and was looking at extending the design to the 8086 architecture.
I had heard rumors of a task force that was looking for a low-cost system design.
The project sounded interesting, but I was enjoying the DataMaster work.
Then my manager called me in. He told me that IBM's Boca Raton division had been
given the job of building a low-cost system. Management had assembled a team of
engineers, and they needed someone to write the control code. I was to join 11 others
in daily meetings at 8 a.m.
At that time, the design for the machine existed only as a few descriptive charts.
A year later, on August 12, 1981, we announced the IBM Personal Computer. Here is
the story of how we made the design decisions that shaped the IBM PC.
The DataMaster program began in February 1978. Many of its design elements — the
keyboard, for example — were later used on the IBM PC. This same development effort
also produced a group of trained engineers already familiar with personal computer
The DataMaster was a single-element design. The one-piece package contained the
keyboard, a 12-inch monochrome display, and a pair of 8-inch floppy disk drives.
Although this design was suitable for the System/23 business environment, it didn't
have the flexibility needed for a personal computer.
The DataMaster's 8-bit 8085 CPU was a very close relative of the 8080 and executed
the same instruction set. During the design team's work on the DataMaster, we ran
up against the limits of the 64K-byte address space and had to invent an external
paging mechanism to address at least 256K bytes of memory. In designing this system,
we became familiar with the Intel architecture and support chips.
The DataMaster system had a built-in BASIC interpreter, just like many of the
personal computer designs of the time. During the DataMaster development, we "converged"
our BASIC with the BASIC used on the IBM System/34. That change delayed the DataMaster
by nearly a year.
That experience taught us two things about getting a product to market rapidly:
We needed to use an existing BASIC, and we needed to streamline the IBM development
process. Applying what we learned was one of the reasons for the success of the
IBM PC. We went to Microsoft for a BASIC interpreter. And we used our own fast-path
development process, which included using executives to convince the rest of the
corporation that we were on the right track.
The First View
Refinement of the original PC design swapped the positions of the power supply
and the expansion cards, allowing the adapters to extend the full length of the
box. That move put the power switch in the back corner — a long reach for users.
In the initial design, we included a pair of 5½-inch floppy disk drives, a horizontal
system board, and five expansion slots. Because of our experience with the DataMaster,
we made the keyboard and display separate from the computer. The basic logic was
to go on the system board, but expansion cards would give each system a unique flavor.
The width and depth of the box had to fit on a standard desk-top and still leave
room for the keyboard. After subtracting areas for the power supply and disk drives,
the remaining space determined the size of the system board and expansion cards.
The initial system design was quite different from the device we finally announced.
We shipped all systems with a minimum of 16K bytes of RAM on the system board. All
systems had 40K bytes of ROM, which consisted of a 32K-byte BASIC interpreter and
an 8K-byte BIOS. Our first design called for a total of five slots — exactly the same
number that ended up in the finished product. We wound up actually developing most
of the features on our original list, with the exception of the 8-inch disk drives;
also, we changed the printer adapter to an industry-standard parallel port.
A major influence on the system design was the just-enacted FCC Class B requirement
for electronic devices in the home. As the industry painfully learned in those early
years, "hardening" the system to contain electromagnetic emissions was difficult,
and sometimes more art than science. We designed the adapter-card brackets to fit
securely in the enclosure to reduce the leakage. Many hours of testing, including
some open-field work conducted in the Everglades (where bug removal took on a completely
different meaning), were necessary to make the system pass the FCC criteria.
We had learned from the DataMaster development and from the experiences of others
that even a company the size of IBM couldn't develop all the hardware and software
to make a personal computer a success. From the beginning, we decided to publish
data concerning all the hardware and software interfaces. Anyone designing an adapter
or a program to run on the IBM PC would get as much information as we had available.
A compilation of all the system specifications used during the system development
and testing became the Technical Reference Manual.
This wire-wrap board was the original planar built to prove
the feasibility of the IBM PC design prior to laying out the printed circuit
board. A similar one was built and shipped to Microsoft in December 1980 for
development of the software. The photo above shows the top of the board; the
photo below shows the bottom.
Why the 8088?
There were a number of reasons why we chose the Intel 8088 as the IBM PC's central
- The 64K-byte address limit had to be overcome. This requirement meant that
we had to use a 16-bit microprocessor.
- The processor and its peripherals had to be available immediately. There was
no time for new LSI chip development, and manufacturing lead times meant that quantities
had to be available right away.
- We couldn't afford a long learning period; we had to use technology we were
familiar with. And we needed a rich set of support chips — we wanted a system with
a DMA controller, an interrupt controller, timers, and parallel ports.
- There had to be both an operating system and applications software available
for the processor.
We narrowed our decision down to the Intel 8086 or 8088. The Boca Raton engineers
were familiar with these processors and their support chips. For programmers, the
8086/8088 architecture is a straightforward map from the 8080 architecture. The
Microsoft BASIC group had already ported its BASIC interpreter from the 8080 to
the 8086. There was also a DOS that ran on the 8086. Expansion of the address space
was our primary goal. We chose the 8088 because of its 8-bit data bus. The smaller
bus saved money in the areas of RAM, ROM, and logic for the simple system.
A bonus we got from choosing this Intel processor was the numeric coprocessor.
The 8087 gave the 8088 a fast partner for floating-point calculations. But since
the 8087 wasn't yet available when the PC was announced, we simply left an empty
socket on the board and didn't disclose a use for it.
16K Bytes and Up
The IBM PC was offered with 16K bytes of RAM, expandable to 64K bytes on the
system board. We used 16K-bit DRAM chips because they were readily available. We
built two memory-expansion cards, a 32K-byte and a 64K-byte card. With a fully populated
system board and three 64K-byte cards, you could get up to 256K bytes of memory — at
that time, an impressive amount for a personal computer.
We made one design choice that was unprecedented in a personal computer: to include
parity on the memory. We thought it was very important to detect errors that might
be caused by a failure in the memory and not allow the corrupted data to propagate
further in the system. We believed it was better to halt the machine than to continue
with errors. If an application program wished to change the way the parity error
was handled, it could do so by simply changing the nonmaskable interrupt handler.
Why did DOS end up limited to 640K bytes? The answer is surprisingly simple.
The 8088 has an address space of 1 megabyte. We reserved the upper 128K bytes for
ROM on the system board. We wanted the video memory on the display adapters to be
in the processor address space, so we reserved a 128K-byte section of memory for
them. Finally, we reserved 128K bytes of memory for ROM or RAM on other adapter
cards. At the time, we thought those allotments were generous.
When you subtract the reserved sections, the remainder is 640K bytes. Since the
capacity of the original IBM PC was 256K bytes of RAM, and the norm for systems
at that time was 64K bytes, we felt comfortable with the design. Although 640K bytes
did become a limitation, so did the other reserved areas. I don't think there was
a better way of arranging the memory that would have made a significant difference.
Supporting the Processor
The support chips brought a lot of function to the IBM PC. DMA speeds up the
I/O performance by relieving the processor of transferring the data between memory
and I/O devices. We wanted the system to be able to perform multiple operations.
A good example is allowing the user to type ahead on the keyboard while the disk
transfers data. This feature enhanced the system's convenience and utility. We also
used DMA for memory refresh, since it already had the control logic to request the
bus and provide addresses to memory.
Being able to type ahead also requires keyboard interrupts. Using the eight-level
interrupt controller relieved the processor from checking I/O operations continuously.
Even though the hardware and firmware shipped with the system didn't take full
advantage of the DMA and interrupt capabilities, we included these functions for
others. For example, the BIOS for the serial port didn't use the interrupt capabilities,
but the serial communications built into Advanced BASIC did. Serial transmission
and reception could take place under interrupt control while the BASIC program was
The three-channel timer/counter let the IBM PC tell time, at least as long as
the power was on. It was also the refresh timer and generated tones for the speaker.
In addition, the counter could be used for many of the system's timing functions — for
example, the code in the BIOS that read the cassette storage device. That code used
the timer to determine the length of a bit cycle and decide whether a 1 or a 0 had
Color and Text
We designed the IBM PC for two different roles: a business computer and a home
computer. To support this versatility, we developed separate video adapters: CGA
for the home and the Monochrome Display Adapter (MDA) for business.
MDA was based on the DataMaster display, which was monochrome and text-only.
DataMaster used the Intel 8275 CRT controller to generate the display. While the
8275 cut down on memory contention (by buffering each row of characters internal
to the chip), it had two problems: It was limited to 7 bits for each character and
so could display only 128 different characters, and it could set character attributes
only by sacrificing a character position to the attribute specification. Thus, highlighting
a word required a preceding and following attribute byte — one to turn on highlighting,
and one to turn it off.
MDA has a single mode, 25 rows of 80 columns of text. We didn't use the DataMaster
design because we preferred to do our own — using the Motorola 6845 for video timings —
and put memory on the card for character and attribute storage. This design allowed
us to have 256 characters, and we could specify the attributes for each character
position. MDA was the first multifunction board developed for the IBM PC. It had
a single parallel port to connect it to a printer.
For the IBM PC, we needed at least 256 characters to support the major languages,
because the I in IBM stands for "international". Our experience with the DataMaster
gave us a pretty good set to use. We also wanted "business graphics" in the character
set (e.g., the lines and corners used to form boxes). We filled the remaining spaces
with some word processing marks, Greek letters, and a few math symbols.
We wanted CGA to be able to work with a home TV as well as with a TV-frequency
monitor. That criterion pretty much determined all the important things — like the
number of dots on the screen. Two of the modes, 40- by 25-character text and 320-by
200-pixel all-points-addressable (APA), are constrained by the limits of a home
TV. The remaining two modes, 80- by 25-character text and 640- by 200-pixel APA,
require a monitor. The color capabilities were determined by the memory we could
afford to put on the board — 16K bytes of RAM. That amount of memory allows four colors
for the medium-resolution APA and two colors for high resolution.
The organization of the memory, 16K bytes by 8 bits, gave rise to one of the
problems of CGA: In 80-column text mode, the adapter had to fetch 160 bytes per
line — 80 characters and 80 attributes — leaving no time for the processor to read from
or write to the display. Any program that went directly to the display memory
quickly filled the screen with "snow". The read and write routines in the BIOS waited
for horizontal retrace before accessing the memory. The scroll routine in the BIOS,
which had to move lots of data, simply turned off the display, did the move, and
then turned the display back on. There was a noticeable blink as the screen scrolled,
but it was less objectionable than the blizzard that would have occurred otherwise.
Cassettes, Then Diskettes
Because we planned on people using the IBM PC at home, we included a port so
a cassette could be used as a storage device. The system was available with no disk
drives, 16K bytes of RAM, and Cassette BASIC in ROM. With this configuration, you
could load and execute BASIC programs from a standard audio cassette tape player.
We did optimize the system design for business use, though, with bays for two floppy
disk drives and 64K bytes of RAM on the planar.
Disk-based systems far outsold those without, and just about everyone who bought
a cassette system eventually upgraded to disks. Although the cassette port was retained
on the PC for compatibility, we removed it from the XT when that was designed.
Bus Architecture: DataMaster Descendent
The IBM PC's bus architecture came from two sources: the DataMaster definition
and the new requirements of the 8088. We wanted to keep the bus very similar to
the DataMaster's, since we had developed several adapter cards for that bus. Keeping
the bus similar would make the adaptation very simple — just a new layout of the cards.
The 62-pin connector also came from the DataMaster. The extensions for the 8088
were obvious — a few extra address lines. The DataMaster used the same interrupt controller
and a similar DMA controller, so those signals were already on the DataMaster bus.
The final definition changed only five of the originally proposed signal lines.
One thing we didn't foresee when we defined the system bus was the proliferation
of adapter cards for the PC. Although the variety turned out to be a good thing
because it gave customers a wide choice of options, we hadn't allowed enough I/O
addresses for all the cards that eventually were developed.
Original expansion cards decoded only a 10-bit address, and many cards used 8
or 16 addresses. Consequently, almost every card ended up with a set of switches
to select the I/O address it would respond to and the interrupt line it would use
in a given system. While the DIP switches were workable, they required the user
to review all the documentation every time another card had to be installed. The
answer was a programmable method of device selection, which was one of the reasons
for the change to the Micro Channel architecture in the PS/2 family.
The IBM PC keyboard came from the DataMaster. We changed the key tops to reflect
the general-purpose nature of the PC, replacing labels such as HELP with F4. Since
the DataMaster keyboard was inside the system box, it used a parallel connection
to the system board. For the IBM PC, we made the keyboard separate and connected
it to the system via a serial port and a 6-foot coiled cable.
One of the questions often asked about the IBM PC is why we chose the Ctrl-Alt-Del
reset sequence. We proposed Ctrl-Alt-Del as a warm-boot sequence to provide some
of the capability of a reset switch. It is difficult to activate by mistake, since
the keys are widely separated. By storing a special character in a particular memory
location, the warm boot would bypass the memory-test portion of the power-on self
test (POST), taking less time than turning the machine off and back on.
The difficulty with Ctrl-Alt-Del, however, is that for the reset to work, the
system must be capable of receiving input. If the program has gone completely off
into the weeds and has disabled the interrupts, the reset won't work. But production
software should not exhibit this kind of behavior.
There were two other concerns with the original keyboard: the placement of the
Left Shift and Enter keys, and the lack of indicators for Caps Lock, Num Lock, and
Scroll Lock. The keys ended up as they did because we wanted to support the international
keyboard, which has several additional keys. We improved the layout with the IBM
AT keyboard. That keyboard also had the indicator lights for the shift states.
Firmware and Diagnostics
We intended for the PC's BIOS to serve as a buffer between the hardware and a
programmer. Some of the things it handles (e.g., sending a character to the printer)
are very simple. Other operations (e.g., decoding the scan codes from the keyboard
into the desired characters) are very complex. We wanted a programmer to be free
to concentrate on the problem, not the hardware.
Another important part of the IBM PC was its diagnostic strategy. The POST annoyed
some users because the system came to life slowly. But we thought it was important
to test the system before turning it over to an application, reasoning that it was
better to find a hardware problem before it caused a mistake in your data.
When we first began development of the IBM PC, we didn't appreciate the potential
of the product. The company originally estimated it would market a total of about
250,000 units over a five-year period. As it turned out, there were some months
when we built and sold nearly that many systems.
IBM has since delivered millions of PCs to the marketplace. The sales estimates
may have been faulty, but the product certainly wasn't. I'm very happy to have been
a part of it.
David J. Bradley is the manager of Advanced Processor Design, Entry Systems Division,
at IBM (Boca Raton, FL). He was a member of the original team that designed the
IBM PC and has a Ph.D. in electrical engineering. He can be reached on BIX c/o