Programming Windows: We Fought the Web and the Web Won (Premium)

Microsoft dragged its developer base into a losing battle against open source and open standards that lasted for decades. And yet, despite its recent and thorough embrace of openness, Microsoft continues to provide new proprietary solutions to its developers and customers alongside its more open offerings, especially in Windows and other legacy products. Doing so seems like an unnecessary delay to the inevitable shift that has happened elsewhere in the company and in the broader industry.

It’s been a while since I’ve written a post in the Programming Windows series, and this entry is most decidedly out of order with the rest. It could, in fact, be viewed as a potential summary for the entire experience. The first—and completed—half of the Programming Windows story concerns the pre-.NET days, and I played an active role in that world as it unfolded between 1985 and 2001. The second half, of course, concerns .NET and everything that has happened since, and I was more of an outside observer during this period.

Reliving the pre-.NET days was, for me, a joy, something I could almost manically communicate quickly and almost effortlessly. But the .NET era has required more research and more time. I’ve had to retroactively experience languages and developer frameworks I never really used professionally and try to make sense of them years after their releases. You’ve seen some of my efforts along those lines in the Windows Forms, Windows Presentation Foundation (WPF), and Universal Windows Platform (UWP) versions of my .NETpad app.

But I haven’t yet written the story of those advances, and the series is currently stalled right at about the start of the .NET era. But I have been thinking a lot about the underlying industry changes that drove the decisions Microsoft made during this time. And a sweeping narrative is beginning to reveal itself, one that spans not just the .NET era, but the entire lifespan of Windows. It’s the story of programming Windows, sure. But it’s also the story of Windows and Microsoft as well.

I think of this history in terms of inflection points, of how Microsoft reacted to what was happening elsewhere in the industry. From its start, Windows itself was a reaction to the Graphical User Interface (GUI) and so-called WIMP (“windows, icons, menus, pointer”) user experience. This type of interaction was invented in research labs in the late 1970s, and it was first brought to the mainstream consumer market by Apple. But it was popularized, of course, Windows, which Microsoft created as a hedge to ensure that its platforms, and not those made by Apple, IBM, or others, would continue to dominate.

The next inflection point was the rise of UNIX, arguably the first major open platform (though, yes, that only occurred over time). Microsoft’s reaction to this platform was to create a platform-agnostic UNIX killer, originally called NT and built by a skunkworks team hired away from Digital Equipment Corporation (DEC). NT allowed Microsoft to sever its ugly relationship with IBM and, again ensuring that its platforms, not others, would continue to dominate.

When the World Wide Web (WWW) happened in the mid-1990s, Microsoft was slow to react. But then Netscape’s Marc Andreessen, still in his early 20s, was declared the next Bill Gates. And when he uttered his infamous and prophetic assessment that the web browser would become, in effect, the real operating system while Windows would be relegated to little more than “poorly debugged set of device drivers,” Gates and Microsoft finally woke up.

The result was an Internet tidal wave. Microsoft’s reaction was to firmly embrace the web—a bit too firmly, as it turns out, since Microsoft ended up reversing a lot of this work after a few years—and to destroy Netscape in the process. Destroying the competition was something Microsoft was quite good at, and its history is littered with the corpses of Ashton-Tate, Borland, Digital Research, Lotus, WordPerfect, and many, many others. But by this time, Microsoft and its platforms were truly dominant. And while busy killing Netscape, Microsoft found itself in the crosshairs of antitrust action in the United States, Europe, and elsewhere that would consume it for the next 15 years.

Microsoft could have learned from the mistakes of this era, could have led its developer and customers down a path in which proprietary Windows and Microsoft-only solutions gave way to open standards and systems. But it continued down the same proprietary path as in the past. In fact, its next major platform, called .NET, was born out of a desire to embrace the best of the web and open standards—XML, SOAP, and so on—and extend it via a proprietary platform that ran only on Windows, on both the client and server.

That Microsoft at the time promoted the openness of .NET only adds to the hypocrisy. And Microsoft also tried to fragment .NET when it introduced Longhorn by making the platform not just proprietary but locked to that one version of Windows. A revolt from its developer ranks prevented this from happening, but it’s perhaps telling that Microsoft was willing to turn its back on .NET’s openness story just a year or two after it was introduced.

And let’s not forget Linux.

When Microsoft CEO Steve Ballmer described this open-source version of UNIX as a “cancer,” he was perhaps closer to the mark than his critics are comfortable admitting: The open nature of Linux meant that there was never a single corporation to target and no way to effectively counter its viral-like growth. If the web was Microsoft’s Vietnam—and I’m making the case that it was—then Linux was its Afghanistan. But the real damage from Linux ultimately came on the server-side, and it evolved to data centers and the cloud over time.

The threat of Linux on the desktop client was never more than imaginary. That said, it is interesting to recall that Microsoft went to the extraordinary lengths of creating a new version of Windows XP, called Starter Edition, because its current platform of the day, Windows Vista, could not run on the netbooks that entered the market running Linux. (Imagine Microsoft issuing a new version of Windows 8 today for low-end computers.) That’s all you need to know about how serious Microsoft was about stopping Linux at all costs: It literally compromised the latest version of Windows to make it happen.

Most recently, of course, mobile computing exploded with the release of the iPhone in 2007, and Microsoft’s response might be considered comical today if the impact wasn’t so tragic and long-lasting. Because of a particularly divisive individual running Windows at the time, Microsoft engaged a strategy so damaging to Windows as a platform that it still seems like purposeful treason.

The mistakes of Windows 8 were many.

Microsoft correctly saw the threat of mobile to Windows, but instead of integrating its innovative Windows Phone platform into Windows for tablets and other touch-first devices, it wasted time by creating a similar but different and incompatible mobile platform and integrating that into Windows instead. It then hid the classic Windows desktop UIs, even on desktop PCs, forcing users to use these immature new mobile interfaces. And it created a new mobile application model, one that wasn’t even based directly on .NET, stranding developers and their existing applications with technologies that would never again be updated. Windows 8 wasn’t just a perfect storm of strategic mistakes, it was insanity.

Concurrent to all this, less politicized and more logical voices inside the company were finally heard when the firm’s leadership shifted from legacy to modern with the ouster of Steve Ballmer and the rise of Satya Nadella. Microsoft forked .NET, with a truly open and cross-platform compatible version called .NET Core developed alongside the old proprietary version and set to replace it, as .NET 5, later this year. Microsoft has embraced open source and open standards at every level in its developer stack, from tools like Visual Studio Code that even Linux developers celebrate, to the Chromium web engine and various open-source developer frameworks. Microsoft’s cloud-based crown jewel, Azure, today hosts more Linux and open source workloads than it does proprietary Windows-based workloads. Microsoft is for the first time shipping its own Linux-based Edge platform in Azure Sphere. And even Windows has been injected with a healthy dose of open source, courtesy of the Windows Subsystem for Linux inside of Windows 10.

The problem is that this enlightened part of Microsoft has made few other inroads with Windows 10, which is still confusingly packed with data mining, targeted advertising, and crapware. And from a software development perspective, Windows is still stuck in the past: Sure, the new technology that Microsoft announced last week is based on .NET 5, which is ostensibly open, but the Windows bits remain locked solely in Windows. The firm even plans a new proprietary version of Windows 10 called Windows 10X.

Looked at another way, developers who want to create Windows applications today have more choice than ever, though most of those choices are years or decades old and have rarely, if ever, been updated in meaningful ways. But few developers would ever target only Windows when creating a new application. And the number of choices is itself problematic. Developers who want to create apps that run not just on Windows but also on more popular platforms like the web, Android, and iOS, should have an obvious choice, not a menu of different and confusing options. And that choice needs to come from Microsoft: Apple’s not going to make such a thing. And while Google might—Flutter, perhaps, comes closest to satisfying this idealistic future—we should never trust this company to do the right thing where Microsoft and Windows are concerned.

Shifting and evolving technology, like democracy, I guess, is messy. And it doesn’t happen overnight.  But I feel that what developers need from Microsoft is a single way to create first-class rich applications that run well across all of the biggest platforms and offer native capabilities on each. What developers don’t need is yet another new framework that targets only Windows, or only Microsoft’s own platforms.

Where Apple and Google race forward to embrace new technologies, Microsoft spends most of its time supporting technologies that it created years or decades ago, and no developer is left behind. Project Reunion, for example, can be seen as a long-overdue path forward for both Win32 and UWP developers, and that’s good on one level.

But this kind of inclusivity, while admirable, can also be seen as a dead weight around Windows and its users and is the real reason we’re all still stuck in “Win32 hell,” where the only applications its users want are legacy applications built on legacy technologies. Microsoft’s inability to move forward has hurt us all, and the failures of incompatible platforms like Windows Phone/Mobile, Windows RT, Windows 10 S Mode, and Windows 10 on ARM only serve to emphasize this point. It may literally not be possible to push Windows forward unless and until Microsoft severs its connections to the past. And that is a move the firm seems incapable of even considering these days, despite its embrace of openness elsewhere in the company.