Programming Windows: A Quick Progress Report (Premium)

6 weeks ago, I set out to tell the history of Windows from a different perspective. Here’s a quick progress report on that work.

It’s going faster than expected, though the pace will slow over the next three weeks because of my home swap in Amsterdam and a vacation we’ll be taking in the middle of that. But so far, I’ve published 23 articles, which is roughly half of what I’ve have planned. That said, there will be a lot of additional content that’s not in the current table of contents, and I suspect this figure is closer to one-third of the final tally.

Speaking of the TOC, I published an early peek at that in last week’s Ask Paul. If you missed it, no worries: It’s a moving target and I’ve already updated it since then. So here’s the latest version which, again, will change over time as well.

Introduction

A Timeline

Pre-History

In the Beginning

Wintel

Windows API

Hello, World

Windows Application Basics

Hello, Windows

Windows API Wrap-Up

BASIC

Microsoft Basic

Hello, Microsoft Basic

Visual Basic Beginnings

Hello, Visual Basic

Visual Basic Takes Over the World

Visual Basic to the Future

NT

Microsoft OS/2

NT

The Windows NT Death March

NT Everywhere

C++ and MFC

Object-Oriented Programming

Hello, C++

Hello, MFC

Microsoft Foundation Class Library

Components

DDE, OLE, and COM

DCOM and COM+ – ActiveX, etc.

Worlds Collide

The Internet Tidal Wave

Netscape, Java, and JavaScript

Hello, Visual J++

Open Source and Linux

Antitrust

.NET

COOL and Windows DNA

Microsoft .NET and Managed Code

C# and Visual Basic .NET

Hello, C#

Hello, VB .NET

Windows Forms

Hello, Windows Forms

Windows Presentation Foundation

Hello, WPF

.NET Core

Hello, .NET Core

Modern APIs

From Metro to Modern

Hello, Windows 8

Universal Windows Platform

Hello, Windows 10

Now What?

In addition to the topics shown above that I’ve not yet written, many of which will be expanded on from what you see in the list, there are some other topics I’ll be adding back into the parts that seem complete already. These will include interviews, over time, though I will likely wait until I get back from Amsterdam to even think about that. But also more coding.

Speaking of which, there are two topics I’ve become semi-obsessed over during the course of writing this tome-like article series: Windows API programming, which is unbelievably unsophisticated in many ways and a huge curiosity to me, and the Microsoft Foundation Class (MFC) library, which could still be a lot better than it was/is. I’ve continued exploring both, and I suspect that I’ll have more articles about each in the future, and will slot them in wherever it makes the most sense. I’m particularly interested in using the original Windows SDK documentation to write a 1985 version of Hello, Windows using the versions of Microsoft C, the SDK, and Windows that were current at that time. Everyone needs a challenge.

Speaking of code, some have wondered about the point of using simplistic hello, world-style applications. I think they’re fun, and my goal isn’t to teach anyone how to program, but rather to show how things changed over time. But the hello, world stuff will get especially fun as we move into components. Bear with me.

Also, I’ve also some moments of epiphany (for me, anyway) about the connections that I had never seen before between technologies. Some of that will be described in future articles, like the direct connection that goes straight from DDE and early COM to .NET. Some of it keeps me up at night, literally, as I wonder about what might have been had Microsoft not made certain decisions, especially around always maintaining backward compatibility. This was, in some ways, its greatest strength, but I feel that the benefits were always short-term and that Microsoft should have been more aggressive about just making things better when possible. MFC and Win32, in particular, were missed opportunities to set things right.

So, too, was Microsoft’s inability to just create new things instead of just responding to or copying what others had done. I ranted about this a bit in my editorial No, Bill. No (Premium), but the point is made. This will come to a head as we move into components, especially distributed components and then the Internet. But it was true of OSes and applications, too, and I was particularly struck by a comment I read (in Byte, probably) that Microsoft was in the early 1990s for some reason content to just copy and not create new product categories, as Lotus had done with Notes. That failing continues to today, of course: Just look at Slack and Microsoft Teams.

Anyway. I may bounce around a bit as I write future articles, meaning that they won’t necessarily be written in the order you see above. But there is a lot more to come, and this project has been curiously satisfying for me. I hope it has been for you as well.

Paul