Programming Windows: The .NET Era (Premium)

After a two-year wait, I’m happy to announce that I’m returning to my Programming Windows series and will pick up where I left off. But it’s been a while, so here’s a recap of the journey so far, and a peek at the journey ahead, which I think of as … the .NET era.

Note: These articles are not ordered exactly as they were published chronologically. That’s by design: I sometimes wrote them out of order, as I will continue to do. Sometimes, you come across information you realize should have been included, or that you hadn’t known about before. So you can kind of think of this in the same way that one would a book. It’s never written front-to-back. It can’t be.

Programming Windows, the Series

An introduction to the series, which focuses on how Windows application development has evolved over the years. “I believe that you can’t truly understand any platform—and in this case, how that platform has evolved over time—unless you understand how to create software for it,” I wrote at the time.

Programming Windows: A Timeline

A breakdown of the main product and technology milestones I expected to cover in the series. Plus, this nice high-level explanation for the series: “I see this series as an explanation for why things happened. The history of Windows can be seen as a series of reactions, to competitors, to market trends, and to internal forces that were seeking change.”

Programming Windows: Pre-History

In the beginning, there was Xerox Parc. Don’t worry, we didn’t end up skipping over MS-DOS.

Programming Windows: In the Beginning

The first-ever Windows API (application programming interface) provided by the Windows Software Development Kit (SDK) consisted of about 450 functions, over double the number available in the C runtime library for MS-DOS. Notably missing was a tutorial of any kind, and Windows development was hard.

Programming Windows: Hello, World

A look at the C programming language that Windows developers needed to master before they could create native applications for this new platform.

Programming Windows: Wintel

IBM’s decision to use readily-available hardware like the Intel 8088 microprocessor would have ramifications for Windows and the PC that would become especially problematic once the industry transitioned from a 16-bit architecture to 32-bit.

Programming Windows: IBM Defends the Original PC

Years later, IBM defended the technical decisions it made when it created the first PC.

Programming Windows: Windows Application Basics

“The real problem with Windows is that it’s hard to write programs for,” Byte’s Jerry Pournelle sagely and correctly noted in the March 1989 issue of that publication. He was right.

Programming Windows: Hello, Windows

To create even a simple “Hello, world!”-style Windows applications, developers had to write a lot of code.

Programming Windows: Windows API Wrap-Up

An overview of how the Windows API—eventually renamed to Win32 as Windows transitioned to 32-bit—evolved over the years with each new Windows version. “Here’s the final irony,” I wrote. “The Windows API, which evolved into Win16 and Win32 but not into Win64, has recently been renamed yet again. Today, it is called … wait for it… the Windows API. Again.”

Programming Windows: Visual Basic Beginnings

Microsoft’s first product was a version of the BASIC programming language for the MITS Altair 8800. And it stuck with BASIC for a long time, creating various versions of BASIC for the IBM PC, including GW-BASIC and QBasic/QuickBasic.

Programming Windows: Hello, Microsoft Basic

Writing a “Hello, world!” app in QBasic or QuickBasic required just two lines of code.

Programming Windows: BASIC Inventors Take on Gates, Microsoft

BASIC inventors John G. Kemeny and Thomas E. Kurtz spent much of the 1980s and 1990s criticizing Bill Gates, Microsoft, and the versions of BASIC that they had ridden to great success. They were at the time trying to sell their own commercial version of BASIC, called True BASIC. And it’s clear that part of their disdain for Microsoft’s BASICs is pure, and driven by their love of their creation. But it’s likewise clear that these two disgruntled educators also used a very public soapbox to sell their own product too.

Programming Windows: Visual Basic Beginnings

Industry pioneer Alan Cooper created a visual interface builder for Windows developers called Ruby, but it needed a programming language. So he showed it to Bill Gates, who immediately understood how this could dramatically simplify Windows app development. So he purchased Ruby for $1 million and told Microsoft’s Tom Button to combine Ruby and Basic into a single product which would be called Visual Basic. Steve Gibson called it a “stunning new miracle.”

Programming Windows: Hello, Visual Basic

How easy was Visual Basic? You could create a “Hello, world!” application without writing a single line of code.

Programming Windows: Visual Basic Takes Over the World

An overview of Visual Basic, which was not really an object-oriented software development tool, but rather an object-based tool in which individual objects supported properties and events. “Visual Basic might have been too good in the sense that it attracted too many amateur developers, at least in the eyes of the professionals,” I wrote. “It made a previously difficult activity, accessible only to professionals with expensive training, available to average people. It exploded the market for Windows applications, but some of them were unprofessionally designed and made.”

Programming Windows: Visual Basic to the Future

A look at Visual Basic’s family tree, which includes such things as WordBASIC, Visual Basic for Applications, VBScript, and Visual Basic .NET.

Programming Windows: Microsoft OS/2

A side trip examining Microsoft’s work with IBM to create an MS-DOS and Windows competitor called OS/2 that eventually used a GUI called Presentation Manager. But a quirk of history prevented OS/2 from taking off, with a tiny team at Microsoft overcoming a key technical limitation of Windows and setting it up for a decade of success in the 1990s.

Programming Windows: Object-Oriented Programming

By the time Microsoft adopted the C for the Windows API, that programming language was already being superseded by an object-oriented extension called C++. “This new take on the language adopted objected-oriented principles and allowed developers to embrace a more modern development paradigm,” I wrote. “But it would be several years before Windows application developers could take advantage of the language improvements in C++, let alone any C++-based libraries that would further reduce the drudgery.”

Programming Windows: Hello, C++

C++ creator Bjarne Stroustrup published a book called The C++ Programming Language to describe his creation in 1985. And he also wrote an introductory “Hello, world!” application for his book that still works today with the latest version of Microsoft Visual C++.

Programming Windows: MFC

Microsoft created a set of C++ class libraries called The Microsoft Foundation Classes that were basically C++ wrappers around the C-based Windows API (Win32). It was hard to use, loathed by developers, and quickly abandoned by the end of the 1990s.

Programming Windows: Hello, MFC

A quick look at some hand-written MFC code, which is much cleaner than the automatically-created garbage that Visual C++ churned out.

Programming Windows: NT

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. This post is a quick recap of the early years of NT.

Programming Windows: The Windows NT Death March

An overview of the two-year death march to bring Windows NT to market, 1991-1993. David Cutler signed off on Windows NT 1.0—which was called version 3.1 to align it with the DOS-based Windows—on 2:30 pm PT on Monday, July 26, 1993.

Programming Windows: NT Everywhere

Windows NT arrived just as the MS-DOS-based Windows 3.1 was taking over the world, but everyone seemed to understand that NT was the future. It was just a matter of time.

Programming Windows: Cairo, a Road Not Taken

This sidebar examines the work of a second NT team, led by Jim Allchin, that was working on a coming major update to the product that was codenamed “Cairo.” Cairo was in many ways as ambitious as the original NT, and it would deliver what computer scientists of the early 1990s considered to be state of the art: An object-oriented desktop built on top of COM technologies, an object-oriented file system built on SQL database technologies, an object-oriented software development environment built on Visual C++, and an object-oriented directory services networking infrastructure. It never happened.

Programming Windows: A Quick Progress Report

A quick recap of the Programming Windows series to date, but broken down by topic, not chronologically.

Programming Windows: Clipboard and DDE

GUIs like Windows had many advantages over the text-based interfaces that preceded them. Some of those advantages are obvious, like graphics and overlapping windows. But some are less obvious, like inter-application communications and data sharing. And even in the early days, Windows supported technologies like a Clipboard for sharing data between applications using copy, cut, and paste. And then a more complex technology called Dynamic Data Exchange (DDE) that could sync data shared between two applications.

Programming Windows: Hello, DDE

With DDE, the source and destination applications would establish a conversation using the DDE protocol, and at the time the conversation was instantiated, it could optionally be configured as a persistent exchange. In that case, the sharing would be dynamic, and the shared data would be “live”: Any change to the data in the source would be reflected in the destination and vice versa.

Programming Windows: OLE

Originally called Object Linking and Embedding, OLE was created to address problems with DDE. Like DDE, OLE allowed developers to create applications that could dynamically share data with other applications—or, conversely, host dynamic data shared by other applications—while maintaining a link between them such that any changes in one instance of the data would impact the other.

Programming Windows: Hello, OLE 2.0

A “Hello, world!” style application, written in Visual Basic 4, that takes advantage of OLE 2.0’s OLE Automation feature to interact with Microsoft Excel 5.0 while running on Windows NT 3.51.

Programming Windows: COM

The Component Object Model (COM) was a more sophisticated take on DDE and OLE, but it was also a new platform in its own right. With COM, Microsoft created a full-featured, object-oriented software architecture that put the firm at the forefront of a new era in software development. One that was based on components and binary-level reuse rather than classes of software code and programming language-based reuse.

Programming Windows: Marvel

Because of the decentralized nature of the nascent Internet and the dominance of America Online (AOL), Bill Gates was somewhat obsessed with online services by the mid-1990s. And so he told a key product manager, Russ Siegelman, to come up with a Microsoft strategy for online services. It was originally named Marvel before being renamed to the Microsoft Network, or MSN.

Programming Windows: Java

Bill Gates and Microsoft didn’t understand the threat from Sun Microsystems’ Java, which they saw as just another programming language. But the threat was real: with Java, Sun had declared war on Microsoft and Windows.

Programming Windows: Hello, Java

A “Hello, world!” app written in Java.

Programming Windows: Netscape Navigator and JavaScript

Silicon Graphics co-founder Jim Clark and Mosaic developer Marc Andreessen teamed up to create the world’s first mainstream web browser, Netscape Navigator. They flew under the radar for a short time, but Bill Gates and Microsoft eventually saw the Netscape threat for what it was.

Programming Windows: Hello, JavaScript

A series of quick “Hello, world!” apps written in JavaScript.

Programming Windows: The Internet Tidal Wave

After years of ignoring the warning signs, Microsoft CEO Bill Gates awoke to the Internet threat embodied by Sun’s Java and Netscape Navigator. And he issued a historic memo, The Internet Tidal Wave, in which he slammed the brakes on Microsoft’s strategy to date and directed all of its employees to embrace the Internet in everything they did going forward.

Programming Windows: Internet Strategy Workshop

Microsoft creates its own web browser, Internet Explorer, to take on Netscape and it bundles the application in Windows. And it “reset” all of its products to embrace the Internet. Next up: embrace and extend Java.

Programming Windows: Microsoft and Java

Microsoft licensed Jave from Sun Microsystems and immediately set out to undermine the platform by making it work better on Windows, where it would have Windows-only features. The result was an incredible product called Visual J++ that let developers create full-fledged 32-bit Windows applications using the Java programming language and a new framework it called the Windows Foundation Classes (WFC). Microsoft’s usurpation of Java was complete.

Programming Windows: Hello, Visual J++

Various “Hello, world!” examples using the two major versions of Visual J++.

Programming Windows: Windows 95

The success of Windows 3.0 and 3.1 had catapulted one of Microsoft’s biggest embarrassments into a worldwide success the likes of which the personal computing industry had never seen. But the next release, called Windows 4.0, and expected in late 1993, would be even bigger. Indeed, by the time it hit the market in August 1995 as Windows 95—the name was changed in July 1994 as part of a company-wide product naming revision—it was clear that this launch would mark the apex of Microsoft’s success.

Programming Windows: Internet Explorer

Microsoft licensed the Spyglass web browser technology to quickly create its own web browser. Early versions were basic, but the product matured quickly and became the market leader.

Programming Windows: More Roads Not Taken

Between the releases of Windows 95 in 1995 and Windows XP in 2001, Microsoft changed its Windows product roadmap several times before it settled on a timeline for merging the 9x and NT product lines.

Programming Windows: Hello, HTML

HTML—the Hypertext Markup Language—is a simple markup language that describes the structure and contents of web documents. But it’s evolved into a powerful platform over the years.

Programming Windows: ActiveX

Microsoft attempted to bring “active content” to the web and take on Java with a COM-based technology called ActiveX.

Programming Windows: Hello, VBScript

Microsoft attempted to take on JavaScript with a homegrown scripting language based on Visual Basic for Applications called VBScript.

Programming Windows: Civil War

Microsoft briefly planned to recreate the Windows shell using Internet technologies like HTML and move developers from Win32 to ActiveX. But an internal battle led by Jim Allchin argued that Microsoft would be crazy to give up its core strengths, and those plans were canceled.

Programming Windows: Happy Halloween

Microsoft initially dismissed the open-source Linux operating system as a hobbyist toy, but an internal assessment quickly changed that view. Open source and Linux were more akin to the War on Terror than they were to traditional wars. Microsoft would need a new game plan.

Programming Windows: Windows DNA

Microsoft moved NT from a client-server model to the distributed computing model used by the Internet. And it branded the collection of technologies that enabled this change as Windows DNA, which awkwardly stood for Windows Distributed interNet Applications.

Programming Windows: The End of an Era

After many delays, Windows NT 5.0 was rebranded as Windows 2000 to indicate that Microsoft was finally merging its 9x and NT codebases into a single product. But that change wouldn’t really happen until a year later.

Programming Windows: Another Quick Progress Report

With my coverage of the 1990s winding down, I provided another quick recap, again by topic.

Programming Windows: Antitrust

Microsoft’s historic U.S. antitrust trial was preceded by an FTC antitrust case that could have been just as damaging. But the software giant agreed to a vaguely-worded consent decree and made no material changes to its business practices.

Programming Windows: Findings of Fact

Microsoft’s historic U.S. antitrust trial was triggered by its bundling of Internet Explorer in Windows and other anti-competitive strategies.

Programming Windows: David vs. Goliath

Microsoft’s aggressive response to the Java and Netscape threats prompted the U.S. Department of Justice (DOJ) to investigate the software giant and then charge it with sweeping antitrust charges.

Programming Windows: Five Words Apart

On April 4, 2000, U.S. District Court Judge Thomas Penfield Jackson issued his Conclusions of Law in U.S. v. Microsoft, asserting that the software giant had violated the country’s antitrust laws through systemic acts of predatory and anticompetitive behavior that harmed competitors, partners, and consumers. The ruling came just two days after four months of tense settlement talks had finally collapsed.

Programming Windows: Fallout

With Microsoft’s antitrust problems mounting, Bill Gates stepped down as CEO and took a more active role in product development as its Chief Software Architect.

Programming Windows: Visual Studio

By the late 1990s, Microsoft had multiple programming languages, runtimes, and developer environments. And so it sought to consolidate them into a single product called Visual Studio.

Programming Windows: COOL

Unable to use Java, Microsoft began work on a competitor that would offer the same C-like object-oriented capabilities along with a WFC-like runtime. It originally had a pretty COOL name.

Programming Windows: Anders

Anders Hejlsberg has been doing the impossible since his first foray into programming languages and compiler design in 1980. At Microsoft, he created C# (originally called COOL), key parts of .NET, TypeScript, and more.

Programming Windows: Microsoft Announces .NET

The launching pad for the second half of this series examines Microsoft’s confusing introduction of .NET, which started life as the Next-Generation Windows Services (NGWS).

More soon.