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
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
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 design.
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
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
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
- 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
- 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
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
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
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 executing.
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 been recorded.
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
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
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
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
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 "editors".