| This Month's
Feature Article | Bug++ |
| New
Products | Latest Product
News |
Editor's Forum
|
| December 2000
| 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. ♦♦
Question of the Month: Wanna be a columnist? Our Bug++
columnist is too slow and sassy, so we’re firing him. To enter
the open auditions for a replacement, go to www.wdj.com/author/ and
then click on the Bug++ Columnist Wanted link — it’s
not that hard, honest!
Ron Burk, Editor
wdjeditor@hightechinfo.com
|
