Channels ▼

Web Development

A Brief History of Windows Programming Revolutions

First, there was the Windows API and DLL Hell. Revolution # 1 was DDE — remember how hot links let us create status bars showing the current price of Microsoft stock?

About that time, Microsoft created the VERSIONINFO resource, which eliminated DLL Hell. But another group within Microsoft discovered a fatal flaw in DDE: they didn't write it!

To solve that problem, they created OLE (which was like DDE, only different), and I fondly remember a Microsoft conference speaker proclaiming that the Windows API would soon be rewritten as an OLE API, and every control on the screen would be an OCX. OLE introduced interfaces, which eliminated DLL Hell. Remember "in situ" fever, and how we dreamed of the day that our applications would all be embedded in a (apparently very large) Word document?

Somewhere in there, Microsoft got the C++ religion and MFC emerged and solved all our problems again, but with inheritance. Well, OLE wasn't going to take that sitting down, so it re-emerged as COM, and suddenly we realized what OLE (or was it DDE?) was really meant to be all along — and it even included an elaborate component version system that eliminated DLL Hell. Meanwhile, a renegade group within Microsoft discovered a fatal flaw in MFC: they didn't write it!

They forthwith corrected that problem by creating ATL, which is like MFC, only different, and tried to hide all those fascinating details that the COM group was trying so hard to teach us. This stimulated the COM group (or was it OLE?) to rename themselves ActiveX and issue hundreds of pounds of new interfaces (even new versioning interfaces, which eliminated DLL Hell), along with the ability to make all our code downloadable via web browsers, complete with user-selectable viruses (ha — try to keep up with that, you ATL weenies!). Like a neglected middle child, the operating systems group cried out for attention by telling us all to "get ready for Cairo", some weird crud that they could never really explain, let alone ship. To their credit, however, the operating system group did introduce the concept of "System File Protection", which eliminated DLL Hell.

Meanwhile, another group inside Microsoft discovered a fatal flaw in Java: they didn't write it! That was remedied by creating J, or Jole, or ActiveJ (honestly, I can't remember the name), which was like Java, only different. That was very exciting, but Sun sued Microsoft under some archaic law that limits the amount of crapulence any one company can ship in a year. This was clearly an attempt to stifle Microsoft's freedom to create products that are like other products, only different, and resulted in the creation of The Microsoft Freedom to Stuff Money in the Trousers of Congressmen Network (newsletter and $14.75 T-shirts available). Remember the J/Jole/ActiveJ program manager pounding his shoe on the table and insisting that Microsoft would never abandon his product? Silly wabbit! All this could mean only one thing — too little attention for the ActiveX (or was it COM?) group. This incredibly resilient herd of API gushers came back strong with COM+ (shouldn't that have been ActiveX+?), and MTS. (I have no idea why there's no "COM" or "Active" or "X" or "+" in "MTS" — they totally shocked me with that one!) They also threatened to add yet another "+" onto all their buzzwords in the very near future. Around that time, someone was yelling about "Windows DNA" and the "Windows Washboard" for a while, but that died out before I ever figured out what it was.

At this point, Microsoft had been watching the Internet for several years with growing unease. Recently, they came to the realization that there was a fatal flaw in the Internet: well, you probably know what it was. And that brings us up to date with .NET (pronounced like "doughnut", only different), which is like the Internet, only with more press releases. Let's be very, very clear about one thing: .NET will eliminate DLL Hell. .NET includes a new programming language called C# (turns out there was a fatal flaw in Active++Jspresso, so just as well it died). .NET includes a virtual runtime machine that all languages will use (turns out there's a fatal flaw in relying on Intel CPUs). .NET includes a single logon system (turns out there's a fatal flaw in not storing all your passwords on Microsoft's servers). In fact, it's probably easier to list all the things that .NET does not include. .NET is absolutely going to revolutionize Windows programming... until next year.

Related Reading

More Insights

Currently we allow the following HTML tags in comments:

Single tags


<br> Defines a single line break

<hr> Defines a horizontal line

Matching tags


<a> Defines an anchor

<b> Defines bold text

<big> Defines big text

<blockquote> Defines a long quotation

<caption> Defines a table caption

<cite> Defines a citation

<code> Defines computer code text

<em> Defines emphasized text

<fieldset> Defines a border around elements in a form

<h1> This is heading 1

<h2> This is heading 2

<h3> This is heading 3

<h4> This is heading 4

<h5> This is heading 5

<h6> This is heading 6

<i> Defines italic text

<p> Defines a paragraph

<pre> Defines preformatted text

<q> Defines a short quotation

<samp> Defines sample computer code text

<small> Defines small text

<span> Defines a section in a document

<s> Defines strikethrough text

<strike> Defines strikethrough text

<strong> Defines strong text

<sub> Defines subscripted text

<sup> Defines superscripted text

<u> Defines underlined text


Dr. Dobb's TV