COM and Active-X

The real power of ASP however, stems from the Microsoft COM architecture that magically breaks everything in the Microsoft universe down into reusable components with well-defined and easy to use interfaces.

Using COM, (or its web catch phrase alias, Active-X) a developer can bring the entire power of Microsoft to bear in any web application. You can instantiate IE to parse your XML, ask Excel to output dynamic graphs, or tell Outlook to send email for you. Everything in Microsoft is an object and everything can be spoken to using a standard interface from your web page.

COM works by creating objects that have a standard interface such that they can be used by any COM-aware program.

However, to understand COM, it is best to step back and look at the history of the Microsoft architecture.

Back in the 80s, the Microsoft architecture was application-centric. That is, every application in the Microsoft universe worked independently. As a result, each application saved its data in its own special format.

For example, you could not read a Word Perfect document in Microsoft Word. Each word processor program worked in its own way, and exchanging data between them was problematic if at all possible. Users had to rely on special bridge programs or klunky export and import functions that often did a mediocre job.

Consider how hard it used to be to import a spreadsheet into a word processor. You would probably have to export the spreadsheet as plain text, import it into a word processor, and then type in the tabs yourself to make the data presentable. Worse yet, not only did you lose any cool features like column addition, but if you changed any data in the spreadsheet, you would have to go through the same painful process of conversion.

Microsoft was never far behind market demand of course, and quickly modified their architecture towards data-centricity and away from application-centricity.

In a data centric universe, instead of focusing on applications and files specific to those applications, users could think of "documents". Documents could contain any type of "object" including text, sound, animation, spreadsheets, or even types that did not yet exist.

Data centricity requires several things of applications that deal with documents. Specifically, there needs to be a way for applications to:

1. display objects with structures unknown to the application.
2. load and save documents containing objects with structures unknown to the application
3. provide editing functionality for objects with structures unknown to the application.
4. execute commands that manipulate objects with structures unknown to the application.
5. support the drag and drop of objects with structures unknown to the application.

In a perfect data-centric world, users would never again need to worry about applications and application specific files. When users opened a document, the operating system would automatically run the associated application in order to present the requested object.

Any document might include several embedded objects from completely separate applications. Sounds familiar? This is the Web? In fact "Active-X" is simply Microsoft's implementation of the data-centric architectural model.

Of course, the evolution of Active-X has been a long process.

In fact, Active-X was born many years ago in the guise of Dynamic Data Exchange (DDE). DDE was a Microsoft technology that 1) allowed applications to communicate with each other (exchange data) and 2) provided a means for applications to execute commands in other applications.

Unfortunately, DDE was slow, difficult to use, and pretty limited.

Fairly soon after DDE was released, Microsoft rendered it obsolete with OLE 1.0 (Object Linking and Embedding). OLE 1.0 defined the essential "compound document" and specified the standard way for an application to work with a compound document.

Any application could display a document consisting of many different types of objects and you could double click on the object in order to edit it using the native application.

Of course OLE was only a first step. real data-centric architecture was approached with OLE 2.0 that was based on COM objects.

COM objects provided:

1. A common way for apps to access and perform operations on objects
2. A mechanism for keeping track of whether an object is in use and deleting it if it is no longer needed
3. A standard error reporting mechanism and set of error codes and values
4. A mechanism for apps to exchange objects
5. A way to identify objects and associate objects with apps that understand how these objects are implemented

When the internet hit big, Microsoft effectively took COM and renamed it Active-X so that the company would seem cutting edge and internet-focused.

ASP (Active Server Pages)
Introduction to the Web Application Development Environment (Tools)
Server-Side Java