oftware technology goes forward in fits and starts. Bigger advances can cause plenty of information indigestion for technologists. At each leap, a new understanding gap opens up. Such a gap takes learning effort to close. Windows Longhorn is a big advancement for Microsoft, and the understanding gap created is proportionally large. Take heart, there's little that's truly new under the sun. A look at Mozilla technology shows that this road is already laid out. Don't believe me? Read on.
Mozilla: An Application Platform?
Mozilla is the technology behind the Netscape Navigator 6.x and 7.x Web browser. Although Microsoft beat Netscape to a pulp in the "browser wars," the Mozilla technology underneath didn't quite die. Instead, it mutated into an application platform. Mozilla applications such as the Mozilla browser are built on top of this new Mozilla Platform. The browser application is not important for this discussion, but what lies underneath it is.
This platform is a fairly generic group of technologies implemented as a single executable and a set of dynamic link libraries. You can use the executable as a starting point for a wide range of software applications. For example, you can easily create a set of interpreted files that display a window just like any Visual Basic, Java or Tcl/Tk program. Sometimes the resemblance is perfect. Companies are already building on and using the Mozilla platform for commercial applicationssome of which run outside the Mozilla browser itself. Examples are tools such as ActiveState's Komodo IDE, Pearson Education's Longman dictionary-on-CD software, and Crocodile Clips' e-learning tools.
In the tradition of modern software tools, the Mozilla Platform isn't small, either. It contains about three thousand object-interface combinations, and half a dozen different integration technologies. The source code for the platform is one of the biggest Open Source projects in the world (Open Office and the GNOME Desktop Suite are larger). It's far bigger than the Linux kernel source. It's far bigger than Perl.
Mozilla Platform Redux
Mozilla has a complete, separate, and enhanced implementation of Microsoft's COM, called XPCOM. XPCOM has its own QueryInterface() method, which acts just like the equivalent method in traditional COM. The 3000 object-interface combinations are due to over a thousand XPCOM components, most of which are bundled with the platform in compiled form.
To support these components, the basic infrastructure of the platform consists of several pieces:
- A fancy application-level GUI display system called Gecko. This is a layout and rendering engine.
- A very high-level networking library, called Necko
- Comprehensive XML support for various standards like XHTML, MathML, SVG, RDF, SOAP, WSDL, and UDDI. Additional support for several unique XML dialects, particularly XUL and XBL, which are used to define GUIs.
Mozilla binds these pieces together in several ways:
Software Architecture Reflects Hardware Architecture
- Using data models expressed as XML RDF and by systems that exploit these models at the XML level
- By programmers using XUL and XBL as a starting and integration point for applications..
Software architecture usually reflects hardware architecture, and Windows is no exception. The big elements of a desktop computer are still screen, network and disk. In the past, Microsoft Windows bound all these elements together using the Win32 API, with GDI and NTFS acting as noteworthy sub-components. Of course, there have been many enhancements on that basic structure, like COM/DCOM and DirectX.
Now, with the Longhorn release, Microsoft is finally replacing the integrated Win32 model with separate pieces:
- Avalon (screen layout and rendering)
- Indigo (high level networking)
- WinFS (high-level disk content management)
This new three-way model clearly reflects the hardware.
Windows binds these pieces together in several ways:
- Via .NET, the COM replacement that competes with Java at the object/code level;
- Via data models expressed as XML Schema and by systems that exploit those models at the XML level, and by programmers using XAML as a starting point and integration point for applications.
If these lists and the previous set sound repetitious, they should. Avalon is architecturally equivalent to Mozilla's Gecko. Indigo is architecturally equivalent to Mozilla's Necko. Longhorn XAML and Mozilla XUL are nearly identical at first glance.
Still, they're not quite identical. WinFS has no exact Mozilla equivalent. A messy aggregate of local Web caches and pluggable search engines is the best approximation Mozilla has to offer.
Similarity exists elsewhere, too. On the object integration side, Mozilla doesn't support .NET but XPCOM is a simpler equivalent. On the XML integration side, Mozilla has RDF and overlay systems that perform some of the roles that that Longhorn's use of XML Schema performs.
The details and edges of these gross comparisons are a bit ragged, but overall the similarities are real.