Programming Windows: ActiveX (Premium)

Microsoft announced ActiveX—or as it was originally called, ActiveX Technologies—in March 1996 as a way to bring so-called “active content” to the web. Microsoft would “activate the Internet with ActiveX.” Put simply, ActiveX was Microsoft’s answer to Java, in the same way that VBScript and JScript were its response to JavaScript. Internally, ActiveX was based on the COM technologies that Microsoft has earlier created for OLE 2.0, but made smaller, lighter, and faster for the web.

Well, that was the marketing. In reality, ActiveX was just COM rebranded. By this time, Microsoft had expanded the original COM with DCOM (Distributed COM), which completed the original design for COM by allowing components to interoperate across machine boundaries and over a network. This was particularly important for distributed networks like the Internet. In any event, ActiveX, being COM, allowed developers to write code in the tool of their choice using the language of their choice and then access functionality in components that existed on that same machine or on some other host on the Internet.

ActiveX was aimed at two primary use cases: ActiveX components, which were UI-less objects that would run on a web server and provide programmatic functionality like database access; and ActiveX controls, which were to the web what earlier VBX and OLE custom controls were to Windows applications. There were also lesser-known ActiveX technologies, like ActiveX Documents, which allowed corporate users to view Office documents on their employer’s web-based intranet, Active Scripts, which let developers mix and match between different scripting languages, and the ActiveX Server Framework, for integrating Microsoft BackOffice servers with Internet Information Server (IIS), Microsoft’s web server.

But ActiveX controls quickly became the most popular and well-known ActiveX technology. Based as they were on OLE custom controls, ActiveX benefited from several years of developer experience with the underlying technologies, making them instantly familiar. And since OLE controls were so widely used, many were quickly converted into ActiveX controls. Developers could simply use the same programming languages they had been using, and the same tools too. That assumed the tools had been updated for ActiveX, of course. But Microsoft and third-party developer tool makers like Borland moved quickly to meet this need.

This was important: While Java and scripting languages like JavaScript were immediately popular and drew many developers to the web, many were likewise familiar with tools like Visual C++ and Visual Basic, and they wanted to leverage their investments those products and their underlying languages and frameworks. ActiveX allowed Microsoft’s developer based to move forward to the web without necessarily needing to learn new tools and languages.

Also, Microsoft’s Visual J++ provided ActiveX capabilities for those who did want to learn and use Java as well. And Microsoft’s version of Java could use ActiveX components in the same way that they used Java objects.

ActiveX controls worked much like their VBX/OLE control predecessors in that they exposed properties (attributes) and methods (actions) and could fire events to which the developer could respond using code, either within the control itself or via an Active Scripting language like VBScript or JScript. Likewise, while ActiveX controls could not communicate with each other directly, they could do so indirectly using these Active Scripting languages.

The end-user rationale for ActiveX was sound enough too: Instead of forcing web users to download browser plug-ins or even separate applications to view animations, movies, or other kinds of multimedia, developers could use ActiveX to embed this content in websites. All the users would need was an ActiveX-compatible web browser, like IE.

OK, not like IE, only IE: To see and use ActiveX-based content online, you pretty much needed Microsoft’s web browser. IE 3.0 for Windows was the first version to support ActiveX, and as was the case with Java, this content was added to webpages using the then-new OBJECT tag in HTML 3.2, which replaced the earlier and proprietary EMBED and APPLET tags.

Assuming compatibility wasn’t an issue, a web developer could insert an ActiveX control in a webpage just as easily as developers could insert one in a Visual Basic application. This could help overcome some of the limitations in the nascent web, including providing native application-like capabilities.

Not surprisingly, Microsoft provided many useful ActiveX controls that developers could use fairly immediately. Some of the more notable examples included:

ActiveMovie. This control allowed you to embed popular audio and video formats, including AVI, Apple QuickTime, MPEG (video and audio), WAV, AU, AIFF, and MIDI. And it was extensible, so that other formats could be added by Microsoft and third parties.

PowerPoint Animation Player. Using PowerPoint for Windows 95, designers could create animation, hyperlinks, advertisements, image maps, and more using a familiar Office productivity tool and then compress them and post them on the web.

VRML. Virtual Reality Modeling Language (VRML) was the Mixed Reality of the late 1990s, and this control provided a way to view 3D objects and 3D virtual worlds directly from a web browser.

HTML Layout Control. Before HTML was updated to support better layout capabilities, this control provided exact coordinate control over layout, layering, and transparency. Objects within the layout could be positioned accurately, and given specific height, width, and z-order (depth) attributes. And you could even add other ActiveX controls and control the display with scripting.

RealAudio. This ActiveX control let you embed a RealAudio player in your webpages.

Marquee. This control created a frame in which you could scroll through the contents of an HTML document.

Label. This control would display text at any angle, which was impossible in HTML, or render it along a defined path. And because it was controllable with scripting, like many ActiveX controls, you could animate it, make it grow or shrink, change colors, or otherwise change dynamically.

Chart. This controls allowed web developers to create graphically and statistically complex charts in a variety of styles using inline data or data pulled from a text file.

Many useful third-party ActiveX controls also quickly appeared, including Macromedia Shockwave, an early predecessor to Flash, and Citrix WinFrame, which let Windows applications run within a webpage. According to Microsoft, there were already over 1,000 ActiveX controls available to developers by mid-1996.

ActiveX did solve some problems for Microsoft and for the developers who had standardized on its tools and languages. But it also presented some important problems too.

First, Microsoft said that ActiveX would “embrace Internet standards,” and like COM itself, it was ostensibly open and cross-platform. But in practice, ActiveX was very much a Windows-only only technology as delivered by Microsoft, though it used partners to bring ActiveX to the Mac and create a Netscape Navigator plug-in. Those efforts never really amounted to much.

Unlike Java, ActiveX didn’t come with a runtime environment like the Java Virtual Machine (JVM) which would let components or controls run on non-Windows platforms. Instead, these would need to be recompiled and built separately on whatever platforms the developer wanted to support. On the backend, this meant that only Windows Servers could host ActiveX objects. And on the client, only IE could run ActiveX controls. Put simply, ActiveX wasn’t portable.

Worse, ActiveX was quickly found to have major security issues, despite Microsoft’s attempts to protect the technology with a trust system based on digital signatures. Because ActiveX controls and components were compiled binaries, just like Windows applications, and because they were installed on your PC when you viewed a site that used them, they could be as malicious as they were powerful. This wasn’t a big problem internally on corporate LANs that used a Microsoft infrastructure. But it was a serious issue on the public web, where Java’s sandboxing approach to security made more sense.

In any event, Microsoft did its usual stellar job of supporting ActiveX across its various developer tools. Starting with Visual Basic 5.0, developers could create ActiveX controls using Microsoft’s RAD toolset. And it even released a free version, Visual Basic Control Creation Edition, that could only design ActiveX controls. Visual C++ was upgraded to support ActiveX control creation via the Microsoft Foundation Classes (MFC) and the simpler Active Template Library (ATL). (Actually, Visual C++ developers could also use something called the ActiveX Controls Framework, or ACF, but this required an in-depth understanding of COM, which was rare, and it could only build very light controls.) Finally, Visual J++ 6.0 could also be used to create ActiveX controls using the Java language and Microsoft’s Windows Foundation Classes (WFC) framework.

Ultimately, ActiveX was more complementary than competitive when it came to Java. Indeed, Microsoft engineered its own Java such that developers could mix and match between ActiveX controls and components and Java objects at will. And ActiveX arguably had a longer-term impact on the web than did Java: Where Java today is most frequently used to create Android apps and Linux server applications, ActiveX continued forward—on the web and in Windows 10—for almost 20 years. And after years of minimizing its availability in Internet Explorer, Microsoft didn’t fully defang ActiveX until Windows, where the Microsoft Edge browser is no longer compatible with this long-lived technology.