Programming Windows: Wintel (Premium)

In 1980, IBM undertook an uncharacteristically fast development process for its first personal computer, cannily named the IBM Personal Computer, or PC. But it needed to cut some corners and bypass some old-school IBM traditions to come in on schedule. So, the first IBM PC was designed by a small team led by Don Estridge in Boca Raton, Florida that operated like a small, very non-IBM-like startup. And rather than leveraging IBM’s big, complicated internal hardware and software systems, the team went with open, inexpensive third-party offerings instead.

This expedient decision created the PC market we still enjoy today with the release of the first IBM PC in 1981. Thanks to IBM’s open design, other hardware makers were able to quickly copy the design, reverse-engineer the few secret bits in its BIOS, and create IBM-compatible PCs, or clones, of their own.

IBM chose an Intel x86 processor for the core of its first PC, instantly catapulting Intel and the x86 architecture to the center of the PC revolution to come. Intel had two x86 chips at the time, the 16-bit 8086, which was first released in 1978, and the 8088, a cost-reduced version that utilized an 8-bit data bus rather than the more powerful 16-bit bus used by the 8086; this was released in 1979. Both chips were technically 16-bit microprocessors because they both had 16-bit CPU registers and internal data buses. But because of the 8088’s more limited 8-bit data bus, it is often called an 8/16-bit design.

IBM chose the 8088 over the superior 8086, but it did so for pragmatic reasons: The 8088 was more readily available in the volume it expected to need, and it and the system boards it required were less expensive.

The 8088’s data bus constrained the system in unfortunate ways because the chip could process 16-bits of data internally, but it could only transfer 8-bits of data externally. In real-world terms, the 8088 was about half as fast as the 8086 at the same clock speed. Worse, this design had serious implications for the operating systems and applications that would run on the PC, and Microsoft and others had to pay close attention to the order in which instructions in its software ran. This made low-level languages like assembly language and then C the ideal choices for developers who would target this platform in the early days.

The Intel 8088 and 8086 ran in a single operating mode called real mode and they utilized a 20-bit segmented memory address space which limited the amount of RAM to 1 MB (1024 KB). That seemed like a lot of memory in 1980/1981—the consumer-oriented personal computers of the day typically offered just 4 KB to 64 KB of RAM, for example—and IBM semi-arbitrarily segmented the available address space to accommodate different needs. The first 640 KB was available to any software running on the chipset (operating system plus an application, typically) while the remaining 384 KB was divvied up between the BIOS, video, and peripherals.

This system would hobble the performance and efficiency of PCs for years to come. But real mode had other limitations, among them its lack of memory protection. So, Intel continued improving the x86 lineup with new generations of chipsets that provided more advanced functionality and performance. And IBM, by and large, slowly adopted most of these newer x86 chips for new PC models as well. So did its competitors, which typically moved much more quickly and offered lower prices when compared to IBM.

Intel released the 80186 in 1982; IBM never used this 16-bit chip in any of its PCs, but Tandy and some other PC clone makers did.

The 16-bit 80286 arrived in 1982 as well, and IBM used this faster chipset as the basis for its PC/AT in 1984. The 80286 was a major advance over previous x86 processors because of its support for a protected mode that provided the memory protection and management functionality that earlier chips lacked. It could also target over 1 MB of RAM.

But things got really interesting in 1985 when Intel released the 80386 processor. This was a fully 32-bit design, and it was the first x86 chipset to provide a flat memory address space rather than the segmented address space used by earlier chipsets. But it was also backward compatible with the 16-bit code that ran on its predecessors, a key factor in its success. Compaq was quick to jump on the 386 bandwagon, effectively establishing itself as the PC clone maker to beat; IBM didn’t adopt this chipset until after the PS/2 launch in 1987, but it still continued to offer 286 designs at that time as well.

(Intel later released a low-cost variant of the 386 chipset called the 80386SX that provided a 16-bit data bus for lower-cost PCs; at this time, the 80386 was renamed to the 80386DX.)

But what about the software?

Microsoft’s MS-DOS was a 16-bit operating system that was written entirely in x86 assembly language. Windows, which first arrived four years later, was written in a combination of assembly language and C. And while developers could create Windows apps in assembly, C, or Pascal, the C programming language quickly established itself as the standard as it was used by Microsoft for its Windows APIs and the Windows SDK.

Speaking of which, you can map each Windows release to the Intel processor architecture (or architectures) they targeted.

Windows 1.0, for example, was a 16-bit application that ran on PCs and PC compatibles based on Intel 8088 and 8086 chips. Windows 2.0 arrived two years later, in late 1987, and while it could be run on newer 80286- and 80386-based PCs in the backward compatible real operating mode, it didn’t take advantage of those systems’ enhanced memory functionality.

For 1988’s release of Windows 2.1, Microsoft split the product into two product editions called Windows/286 and Windows/386. As the names suggest, each took advantage of the unique features available from Intel’s newer processors.

Windows/286 allowed Windows to access more than 1 MB of RAM when installed on a 286-based PC. (It still ran on 8088 and 8086 hardware as well.)

Windows/386, like the 80386 itself, was much more interesting. It was the first version of Windows with a protected mode kernel, necessitating an architectural change in which the real mode tasks of the past—Windows itself, DOS applications, and Windows applications) were all run in virtual 8086 mode containers, for lack of a better term. Window/386 ran in its own virtual 8086 mode box. It could run multiple DOS applications, each in their own virtual 8086 mode boxes, allowing for the first-ever instance of true MS-DOS application multitasking. And it ran all Windows applications in a single virtual 8086 mode box which supported over 1 MB of RAM.

Windows/386 was the first step towards the 32-bit Windows architecture that would define the subsequent decade and a half of the platform. But Windows 3.0 arrived in May 1990, and it was an even bigger second step in that direction.

Windows 3.0 supported three different operating modes, eliminating the need for separate product versions that supported different Intel chipsets. These included real mode for backward compatibility on older chipsets, standard mode (essentially similar to Windows/286 with support for over 1 MB of RAM, and 386 Enhanced mode. Like Windows/386, Windows 3.0 in 386 Enhanced mode supported virtual 8086 mode with a single virtual 8086 mode box for Windows and individual virtual 8086 mode boxes for MS-DOS applications, each of which could now be run in windowed form. It supported PCs with up to 16 MB of RAM.

Windows 3.1 worked similarly to Windows 3.0, but it required at least an 80286 processor, dropped support for real mode, and supported up to (a theoretical) 4 GB of RAM (256 MB, realistically) when running in 386 Enhanced mode. It was also the first to support an optional 32-bit disk access technology, bypassing DOS for this functionality for the first time.

A related product called Windows for Workgroups 3.1 added native networking support for the first time. And Windows for Workgroups 3.11, which arrived in 1993, was a stealth preview of the underpinnings of Windows 95 by also supporting 32-bit file access (which was disabled by default) and 32-bit networking (with TCP/IP coming via an add-on package) and by dropping support for standard mode entirely.

Throughout this time period, the pervasiveness of PCs running Windows on Intel x86-based hardware led to the term “Wintel” as a way to describe the developing duopoly that came to control the entire PC industry between them. That the industry was not dominated by IBM, its creator, is an interesting historical footnote today. But how this happened, and why, also had consequences to the design of Windows.

The short version goes like this: IBM, understandably upset that a horde of low-cost cloners were stealing away the PC market from it by copying its open hardware design and using reverse-engineered and open versions of its BIOS, set out to take back control by releasing a second-generation PC design, the PS/2, that used a proprietary hardware bus and peripherals that cloners would need to license (pay for) to use.

Likewise, IBM was also understandably upset that Microsoft dominated the market for PC operating systems thanks to its far-sighted decision to license and not sell MS-DOS to IBM. So, Microsoft was free to make modified versions of MS-DOS for other PC makers, and over time, it simply made a single version that ran on all PCs. So, IBM set out to replace MS-DOS with an operating system called OS/2.

OS/2 would be co-developed with Microsoft, but the software giant would only be able to license the so-called Standard version of the product to third parties. Those that wanted the full capabilities of OS/2—including advanced networking and database functionality—could only get OS/2 Extended Edition directly from IBM, or preinstalled on IBM PS/2 PCs.

As originally released in late 1987, OS/2 looked and worked much like MS-DOS, but it was a 16-bit protected mode operating system that targeted the Intel 80286 processor. (Windows didn’t do this until version 3.1 in 1993.) A Windows-like GUI environment, called Presentation Manager, arrived a year later in OS/2 1.1. Presentation Manager looked and worked like Windows 2.1 and the plan, as you might expect, was to eventually supplant MS-DOS and Windows with the more powerful OS/2.

But then something happened.

Microsoft and IBM ended up parting ways in 1990 thanks to a series of unrelated events. Microsoft’s developers were routinely frustrated by the slow and dated way in which IBM developed software, and by its increasingly onerous requirements. And separately, the designers of Windows, who had run into a technological wall because of the limiting nature of IBM’s early architectural decisions, suddenly had a breakthrough. The resulting product, Windows 3.0, was immediately popular, both for its support of all modern x86 processors and for its then-new user interface. Microsoft, facing years of indentured servitude to a master that was always jealous of it, could be free of IBM forever.

But IBM’s decision to make OS/2 fully 16-bit gave it a technological advantage over DOS and Windows, and it made it easier to take the system to 32-bits with OS/2 2.0 in April 1992. So, Microsoft began a skunkworks project called NT OS/2 that would run both Windows and OS/2 applications and fully target the more sophisticated 32-bit technologies of modern microprocessor architectures. NT OS/2 was later renamed to NT and then Windows NT, of course, as the popularity of Windows 3.1—released in 1993—and the lack of success of OS/2 (and the PS/1 and its proprietary hardware bus) altered Microsoft’s plans significantly. NT was also designed to be cross-platform compatible so that it could take advantage of non-Intel microprocessors that offered unique advantages of their own.

Regardless of what would happen next, the die had been set. The future of Windows, as seen from the early 1990s, was 32-bit.