 | VS. |  |
Breaking Windows
The narrative starts out with the backstory of how Gates came into his PC desktop monopoly by realizing that software—specifically the computer's operating system—would be an important and valuable part of the PC ecosystem. As PC hardware got cheaper and more prevalent, the software volumes would grow with the spread of the hardware, and at essentially zero marginal cost to Microsoft. All they needed to do was become the defacto standard OS. That's what Gates set out to do, and he succeeded with Windows 3.1 and then Windows 95. The bulk of the story takes place after Microsoft had achieved its monopoly and was deciding on strategies to defend it.
One of the main strategies was to identify competitors that were creating software that was somewhat tangential to Windows or could be added as a compelling feature, and whose software was becoming popular enough to potentially pose a threat to Windows by becoming a new platform. Microsoft would then create their own version of that software and integrate it into Windows or otherwise absorb the other company's software, nullifying the threat to their monopoly.
The most prominent example of this absorption strategy came with Internet Explorer and the browser wars between Microsoft and Netscape. Netscape Navigator started out with nearly the entire market of the World Wide Web before Microsoft got into the browser business. By the time Microsoft had revved up to IE 3.0, they had claimed a significant amount of market share from Netscape, and because of bundling IE with Windows and offering it for free to older versions of Windows, Netscape was doomed to lose in the long (or not-so-long) run.
Everything was not all peaches and cream within Microsoft, though. There were two warring camps fighting for the soul of Microsoft. On one side was the Windows team led by Jim Allchin that was developing the next big thing: Windows NT. On the other side was the Internet Platform and Tools Division led by Brad Silverberg that wanted to leave Windows behind and try to capture as much of this new Internet frontier as possible, using IE as the platform. Gates would end up siding with Allchin and IE became a part of the Windows platform instead of growing into one of its own.
It's almost comical seeing some of these disagreements today. One of the most important features of the IE platform that was integrated into Windows as an option was Active Desktop, but this feature seems so inconsequential today. Making the desktop background a web page was fraught with problems, and all that has survived is a way to enable single-click icons instead of the usual double-click to run a program. I don't think hardly anyone used it, especially after dealing with multiple desktop crashes. I remember it being a novelty for a while, but I soon stopped enabling it because it was so annoying and a double-click is so ingrained in my desktop usage.
Of course, the disagreement with the Justice Department over Microsoft's monopoly was not so insignificant. Part of the reason their tactics got them into trouble was because IE was offered as a free upgrade for older versions of Windows that didn't have it or had older versions of IE. If Microsoft had truly made IE an integrated part of Windows and only released new versions of it with new versions of Windows, Microsoft's competitors wouldn't have had as strong of a case. Microsoft wouldn't have had as strong of a monopoly, either, because IE was getting new versions much faster than Windows was and people that didn't upgrade Windows were still getting free upgrades of IE.
Even so, the government's eventual breakup proposal was preposterous. They wanted to force Microsoft to set prices for Windows versions with and without IE based on how many bytes each version was, like it was produce or meat or something. The government obviously had no understanding of what software really was, no idea how ridiculous that sounded, or what a good solution to the real problems of Microsoft's monopoly would actually look like. In the end that proposal was dropped, and the entire court case seemed to have done nothing more than give Microsoft a ton of bad press.
In the mean time Gates had done plenty of other damage to Microsoft and Windows because of deciding to pursue these retrenchment strategies with the browser and other things related to the Internet. Bank makes the case that Gates should have pursued the Internet platform strategy in order to disrupt his own business and grab the larger market that was just coming to light, but I'm not so sure that would have worked, either. If he had done that, would he have been able to beat Google before they rose to the top, or would he have been able to foresee the coming of mobile and the smartphone before Apple took over with the iPhone? It's hard to imagine Microsoft getting all of that right and still being top dog today. (Although they're now doing quite well now under Satya Nadella.)
There was so much more in this book, like the section on how XML came to be. (Of course bloated, complicated XML was created at Microsoft. In the book it was portrayed as a genius innovation by Adam Bosworth that would help Microsoft take over Internet data flows in spite of Gate's decisions. I'm so glad JSON has stopped that nonsense.) I could keep going, but it's all in the book. It was a wonderful trip down memory lane, covering plenty of things I had forgotten about that were a big deal at the time (remember the AOL shortcut bundled on the Windows Desktop). The book is decently written, if a bit confusing at times. Bank jumps around a lot, and there's no overarching timeline to the narrative. Regardless, it gives great insights into what was happening at Microsoft through all of the turmoil in its history and is well worth the quick read.
Showstopper!
As the subtitle describes, Showstopper! is the story of how the first version of Windows NT was conceived and built. It makes for quite an engaging story, as the NT team was arranged within Microsoft in a unique way for the company. Instead of being a department that reported to and was directly overseen by Bill Gates, the team was more of a startup company within Microsoft that operated fairly independently and was left more or less to its own devices. Gates did check in and imposed some of his own requirements from time to time, but not anything like other departments within Microsoft.
One of the main reasons for this independence was the force of nature that was Dave Cutler, the chief architect and director of Windows NT. Cutler was aggressive and expected incredible things from his team, and he did not get along well with Gates, either. Gates had hired him when Cutler had left Digital Equipment Corp. and respected and trusted him enough to let Cutler run things as he saw fit, so Gates pretty much left him alone.
Cutler had brought along a number of programmers from his team at Digital to be the core of the NT team, and as he took on more Microsoft employees to build out the team, a rivalry emerged between the two groups:
The Digital defectors also were more methodical about their jobs, hewing to textbook engineering practices in contrast to the Microsofties, who often approached a problem helter-skelter. Cutler's people took work seriously, while Microsofties sometimes tossed nerf balls in the hallways or strummed guitars in their offices. The differences in style were apparent to Cutler's people, who derisively referred to Microsoft as "Microslop." By the same token, Microsofties were put off by the clannishness of Cutler's gang.Regardless of these divisions, work got done and NT progressed through big scope changes and constant feature creep. Throughout the project Cutler never really trusted or approved of the graphics team. He had always been a terminal kind of guy and didn't see the need for a GUI, and he did not agree with the graphics team's much more laid back approach to software development. The graphics team was dealing with their own internal issues as well, having chosen a new, immature programming language to write the GUI: C++. While it was a new language at the time and the supporting tools were rough and unstable, G. Pascal Zachary's assessment of the language seems a little off:
While it was portable, however, C was difficult to master and gave a programmer a great deal of latitude, which increased the likelihood of coding errors. A more inspired choice—a gambler's choice—was C++, a newer language that was all the rage among software theorists. By preventing code writers from making mistakes, C++ promised faster results and greater consistency, which would benefit programs that were the work of many people.C++ is hardly easier to master than C! With C++ being a superset of C, C is most certainly the simpler language. While it may be true that C++ can support larger projects, it is also quite easy to make C++ programs much more complicated than C. These kinds of off-the-cuff assessments were fairly common in the book, and they made it seem like Zachary was either over-simplifying things or he didn't fully appreciate the technical aspects of these topics. This tendency to over-simplify was especially apparent whenever he was discussing features of NT. The discussions nearly always dealt in generalities, and it was difficult to figure out which features, exactly, he was talking about. He would mention that features were missing from NT or that programmers were adding features on their own whims without specifying what those features actually were. Not knowing what he was referring to became quite frustrating at times.
Even with the occasional vagueness, other discussions were satisfyingly to the point, like whenever the client-server architecture of NT came up:
Time and again, Cutler had hoped to dispel doubts about client-server. In his design, the kernel code treated the entire graphical portion of the operating system, including the Windows personality, as an application. It was a classic design choice. Client-server ensured reliability but degraded performance. It was probably Cutler's most momentous decision.The performance hit incurred with the client-server model was a constant issue during the development of NT, and it wasn't until near the end of the project, and after a year delay, that the performance was brought under control and near parity with Windows 3.1. The story of how Cutler's team achieved the necessary performance while fixing the innumerable bugs as NT came closer and closer to release was one of the best threads of the book.
The book is also riddled with pieces of advice on software development, most often in the form of little narratives about different aspects of the project and a vast array of the programmers and testers that worked on it. Things like adding programmers to a late project makes it later, working longer hours is counterproductive, first make it right then make it fast, the number of bugs in a system is unknowable, and automated testing and stress tests improve code quality all appeared at various points in the story. It was enjoyable to see all of these hard-won nuggets of wisdom come up and be acknowledged during the course of such a high-profile project.
Sometimes the words of wisdom were quite humorous, too. At one point Cutler had written an email that included this gem: "If you don't put [bugs] in, you don't have to find them and take them out!" Well, yes, that's great. If only it were that easy! Of course he was trying to encourage his programmers to be more diligent and rigorous, but what a way to say it.
Throughout the book, new people were continuously introduced, each with their own mini-narratives told within the larger context of the NT project. It was nice to learn about so many different people that had a hand in the project, and there were dozens of stories related of the approximately 250 people that helped NT over the finish line, but it became exhausting to keep track of everyone as the names kept piling on. The number of people became pretty overwhelming even though only a small fraction of them made it into the book.
The scope and accomplishment that is Windows NT is quite astounding. Nothing like it had ever been done before, and the scale of the project was beyond anything achieved in software development up to that point. The scale of development wouldn't be surpassed until Windows 2000, seven years later. Even with the rough edges and occasional frustrations, the story of how NT was built was a fascinating and entertaining read. I would definitely recommend giving it a read if you're at all interested in how Microsoft managed to revolutionize its Windows operating system.
