Programming Windows: NT (Premium)

In Showstopper! The Breakneck Race to Create Windows NT and the Next Generation at Microsoft, author G. Pascal Zachary recounts the amazing story of how Microsoft created the product that it eventually named Windows NT. I highly recommend this book to everyone reading this series of articles, in part because it is much closer to my ideal for such books than are most industry titles. And, as such, it serves as one of many inspirations for what I’m now writing.

That is, most industry books are more interested in discussing companies, personalities, and strategies than they are in discussing products. But I’ve always been most fascinated by the latter. And this is where Showstoppers really succeeds for me: It’s as much about the product as it is about the company and people who created it. And I love that.

As such, I can’t really hope to surpass what Zachary wrote. So, I will instead off a recap of NT’s early years, before it turned into Windows NT. In a future article, I will continue the story of how Windows NT finally came together and then eventually turned into just Windows.

(Fun aside. NT stands for “New Technology.” I suspect that this name was created posthumously, but there it is.)

The story of NT is the story of Dave Cutler, a systems programming genius who had previously built real-time operating systems for the Digital PDP-11. Cutler, like Gates, was fond of creating the smallest possible code to get the job done. His motto was simple: “Size is the goal.” And he had a rubber stamp made with that phrase so that he could stamp rejections on code that was too large.

In 1985, Cutler was working for DEC in Seattle and he won approval to build a new family of computers named Prism. Its OS was called Mica, and though it was a new design, it would also run Vax applications, assuring that customers could move forward. Prism was billed as a supercomputer at one-tenth the price. But it was canceled in June 1988, and Digital told Cutler it would disband his Seattle-based hardware group.

At that time, Windows was failing and OS/2 was Microsoft’s future. But OS/2 was looking more and more like a disaster: IBM had seized control of the project and it wouldn’t run Windows programs. Worse, a new generation of RISC computer systems were coming, threatening the CISC-based PC platform. So, Gates told Microsoft chief technology officer Nathan Myhrvold to write a “Unix killer.” He wanted a “portable” OS that would run on multiple platforms just in case.

And then two worlds collided. A Myhrvold staffer told him on August 4, 1988 that Cutler’s Prism project was canceled and that he wanted out of DEC. So, Myhrvold told Gates about the opportunity that had suddenly presented itself.

“It was like an amazing coincidence,” said Gates, who had never met Cutler. “I very much wanted to a portable OS. It was not a question of if, but when we could get the team together to do it.”

A meeting was arranged and it was immediately obvious to Gates that Cutler the real thing. Indeed, Cutler didn’t respect Microsoft or its products. DOS was “a toy,” he said. But Gates was overjoyed to hear that Cutler wanted to build a “real” OS. He offered Cutler a job.

Cutler joined Microsoft on October 31, 1988, triggering an exodus of DEC employees, many of which called Microsoft “MicroSlop” in disdain. The NT team wasn’t just different from the rest of the company, they felt. It was better. The culture wars would last for years, and make it difficult for Microsoft employees to join the NT team.

Microsoft announced the hiring on November 10, 1988, and said only that Cutler was working on an advanced version of OS/2. But internally, Steve Ballmer had to keep reminding Cutler that the OS had to run OS/2 apps. He also wanted to NT to run DOS and Windows apps. But Cutler refused. “No one will ever want that,” he claimed.

NT was originally going to run on Intel’s first RISC chip, the i860. Cutler thought it was crappy but agreed. He had three goals for his OS: Portability, “bullet-proof” reliability, and personality. That last one meant that it would be powerful enough to host more than one user interface, or “personality.” NT would support OS/2 Program Manager but it could support DOS or Windows if needed, or other OSes that not yet been invented.

But portability meant that NT would be big. Design-wise, it was split into a so-called client-server design with two major pieces: The kernel, which used a microkernel architecture, and the graphical user interface.

By early 1989, the NT team was already losing patience with OS/2, which Cutler described as “junk.” Cutler was equally unimpressed with Novell Netware, which had inspired Gates to demand that NT be network-capable. Actually, Cutler was pretty much unimpressed by anything he didn’t make himself.

In July 1989, the NT team built its own DIY computer based on the Intel i860, and put the words hello world on a screen. But the chip was indeed flawed, as Cutler had worried. So, the team started looking for a RISC-based replacement.

That September, Cutler and Gates had their first meeting about deliverables, a topic that would become ever more contentious as the NT schedule kept slipping. At the time, Cutler told Gates that OS/2 apps would not run without extensive changes, and that DOS apps would not run at all. Neither would OS/2 drivers. But the team felt it could get a minimal NT up and running by January 30, 1990. So, Code complete was set for July 30, 1990, and a version for application writers was set for on October 30. Microsoft would deliver a so-called “Golden Master” version of NT no later than March 30, 1991.

None of that would ever happen, of course. NT was delayed again and again for any number of reasons.

First up was the port to the Intel 80386, the powerful 32-bit chip that was then driving high-end PC sales. Gates views this port as a top priority, but Cutler thought NT should be RISC-only and was worried that the PC was so popular that it would damage NT’s portability goal because developers would hand-write Assembly Language code, ensuring it would run best on Intel. Gates also added graphics support to his list of requirements.

By January 1990, Gates was already complaining that the 386 port was moving slowly. But it wasn’t just the port: NT was going nowhere fast. So Steve Ballmer told Paul Maritz, who was responsible for OS/2, not NT, to “make sense” of NT. After a brief examination of the project, Maritz delivered the bad news: NT, he said, was “an exercise in technology development,” not a product.

To goad the team into action, Maritz challenged Cutler to get four OS/2 PM applications running on NT in time for Fall Comdex that November. Around this time, the ranks of the people inside Microsoft who were testing NT grew dramatically, upsetting Cutler, who had never relied on testers at DEC.

By Spring, the original schedule was already hopelessly out of date, and there was no way NT would be code complete by July. Not helping matters, the Mips processor that they had selected to replace the Intel i860 had been delayed as well. And there were still doubts about NT’s client-server design, where the OS/2 personality sat outside the kernel like an application. This was secure and reliable, but it was also potentially a lot slower too.

In the wake of the May 22 Windows 3.0 launch, Cutler met with Gates again. Gates was furious the that 386 port was still not complete. He also complained that the NT graphics were too slow. And he didn’t believe that OS/2 apps would run as fast on NT as they did on OS/2. “What you’re telling me is that NT is going to be too big and too slow?” The answer? Yes.

This triggered a June 8, 1990 meeting of the NT team. Windows 3.0 was perceived by reviewers and customers a huge improvement over previous Windows versions. And so the NT team naturally started wondering about the direction it was taking.

“Should our product be called Windows NT,” Lou Perazzoli asked the others in the group. “We outta start looking at Windows manuals,” Cutler replied.

Concurrent to this, Microsoft’s relationship with IBM was falling apart, as was discussed in Programming Windows: Microsoft OS/2 (Premium). Paul Maritz told Gates and Ballmer at the time that Microsoft had to “choose the Windows horse or the OS/2 horse.” Helping make the decision, Microsoft’s support of OS/2 was problematic for NT. The company just didn’t have the resources to simultaneously create new versions of Windows, OS/2, and NT at the same time.

By that July, and no doubt heartened by the early blockbuster sales of Windows 3.0, Gates had made his decision. Windows was now his top priority. And NT would assume the Windows “personality” and run Windows applications. Meanwhile, the firm would try to push NT as a solution to IBM that could run both Windows and OS/2 applications. If IBM accepted this, Microsoft would refer to NT as NT OS/2 while letting the market decide. Which it would, and did, in Windows’ favor. Regardless, NT was finally, officially, part of the Windows family. It was now Windows NT.

“Out of the ashes of OS/2, NT is reborn,” one unnamed participant in Microsoft’s secret meetings in which the new strategy was created is quoted as saying in Showstoppers.

Cutler didn’t seem to care one way or the other about the shift. On the one hand, it “made a lot of sense” to switch to Windows, and they no longer had to deal with IBM. On the other hand, this changed the schedule dramatically, killing the Comdex timeline. And he was worried that the constant shifts and delays would lead to another of his projects being canceled.

But Microsoft was betting big on NT. It wanted a Unix killer, and Unix was Cutler’s “long-time foe.” He thought Unix was a “junk operating system designed by a committee of Ph.D.s.” He couldn’t wait to kill it.

Now that NT would run Windows applications, it needed to support the Windows API. Cutler and his team could have created a new and better-designed API for NT, but “there was every reason why the NT APIs should resemble the Windows APIs.” This would make it easier on existing Windows developers to make the conversion and update their 16-bit Windows apps to run on the 32-bit NT. Making life easier for developers would help ensure that NT could be successful.

“I don’t care what the code looks like,” Cutler told Marc Lucovsky. “Just make it work.”

Cutler’s lack of caring shows, and the result was the Win32 API that we’re still stuck with today. It is as poorly fashioned as the 16-bit Windows API it replaced. And it was created just as quickly: Lucovsky and Steve Wood wrote an 80-page paper describing how the 32-bit NT versions of Windows API functions would look and work in just two weeks. Most were straightforward conversions of the original code, some of it dating back to 1983. The point, they said, was “to hide from the applications writer the underlying differences between Windows on DOS and Windows on NT.” By December 1990, the effort was largely complete, with over 1000 functions converted over to NT, most of them nearly identical to their Windows API predecessors.

In fact, this API conversion played a big role in Microsoft’s divorce from IBM. When IBM’s developers first saw the APIs, they could immediately tell that they were based on Windows and not OS/2. “Couldn’t you have carried over even one OS/2 API?” an IBM engineer blurted out as he surveyed the documentation in a meeting with Microsoft. “No,” Lucovsky replied. “Our goal is to make it easy to go from Windows to NT.” An angry argument ensued.

“The IBMers felt conned,” Showstoppers explains of the meeting. “This whole notion of NT hosting both Windows and OS/2 was a charade. [They] squirmed in their seats, eager for the meeting to end so they could report this shocking news to their bosses … The IBM-Microsoft alliance died that day.”

Running DOS and Windows applications would be big for users, but it was difficult technically because of the diversity of those software ecosystems. Basically, NT had to fool DOS and Windows applications into believing that they were running natively under DOS or Windows. The team exploded in size, in part to accommodate this work.

In November 1990, Gates was still worried about the performance hit of the client-server model, so Cutler pushed the graphics team to up its game so he could create a demo proving that his idea would work. By January 1991, he was able to prove that NT could run graphics-heavy Windows applications just a hair slower than real Windows. The debate over client-server was over, and Gates, finally satisfied, stopped harassing Cutler. Indeed, he stopped talking to Cutler at all, assured that the product was in good hands.

That month, the NT team fashioned a new schedule that they would likewise never achieve. Application writers would get their first NT beta in August 1991. NT would be code complete by October 31, 1991. And NT would ship to customers in the second quarter of 1992.

But there were further challenges. The team wasn’t sure if NT should ship with a new file system or just use the file systems from DOS and OS/2. Some felt that these file systems were crude, but others were more worried about further NT delays. Finally, NTFS was proposed and then development began. It would be able to restore lost files, even if the computer had lost power or totally failed. Jim Allchin, who was then in charge of Cairo, the next version of NT, was against the new file system because he thought it would undermine support for the object-oriented Cairo file system his team was working on. (He was right, it did.)

In February 1991, Cutler demanded that the NT team “eat its own dog food,” and actually run NT. The “dog food diet” was a cornerstone of Cutler’s philosophy, Showstoppers explains. “We’re going to run on the program we build,” Cutler declared. It was horrible, at first, of course. But it got bugs fixed because the system actually had to work. Two and a half years into the project, NT finally getting to the point where it could be used for work.

NT’s dogfooding happened in three phases: NT without graphics, NT with graphics, and then NT with graphics and networking. During this time, the Build Lab turned into the “project’s nerve center,” and it would remain the nerve center for Windows well into the 2000s. The team created a new build once per week, giving testers a snapshot of NT.

On March 12, 1991, Microsoft held an internal meeting in which it lifted the secrecy around NT for the first time and the long-term plans to merge Windows with NT. The number one question from the Microsofties in attendance? “When will NT ship?”

There were nervous looks as the NT team had been told not to talk schedules. And it would be over two more years before NT—sorry, Windows NT—finally did ship to the public.

More soon.