Towards a Web Object Model

The World Wide Web is becoming an increasingly important factor in planning for enterprise distributed computing environments, both to support external access to enterprise systems and information (e.g., by customers, suppliers, and partners), and to support internal enterprise operations. Organizations perceive a number of advantages in using the Web in enterprise computing, a particular advantage being that it provides an information representation which

• supports interlinking of all kinds of content
• is easy for end-users to access
• supports easy content creation using widely-available tools

However, as organizations have attempted to employ the Web in increasingly-sophisticated applications, these applications have begun to overlap in complexity the sorts of distributed applications for which distributed object architectures such as OMG's CORBA, and its surrounding Object Management Architecture (OMA) [Sol95] were originally developed. Since the Web was not originally designed to support such applications, Web application development efforts increasingly run into limitations of the basic Web infrastructure.

If the Web is to be used as the basis of complex enterprise applications, it must provide generic capabilities similar to those provided by the OMA (although these may need to be adapted to the more open, flexible nature of the Web). This involves addressing the provision of higher level services (such as enhanced query and transaction support) and their composition in the Web. However, the basic data structuring capabilities provided by the Web (its "object model") must also be addressed, since the ability to define and apply powerful generic services in the Web, and the ability to generally use the Web to support complex applications, depends crucially on the ability of the Web's underlying data structuring facilities to support these complex applications and services.

The basic data structure of the Web consists of hyperlinked HTML documents. It is generally recognized that HTML is too simple a data structure to support complex enterprise applications [Bos97], e.g.:

• applications that require the Web client to function as the front-end to enterprise applications or mediate between multiple heterogeneous databases,
• applications that require more flexibility in distributing processing load between Web servers and clients, and
• applications that require the Web client to present different views of the same data to different users or in which intelligent Web agents need to tailor information discovery to the needs of individual users.

A fundamental direction of efforts to address HTML limitations has been attempts to integrate aspects of object technology with the basic infrastructure of the Web. There are a number of reasons for the interest in integrating Web and object technologies:

• The Web can already be viewed as a simple form of distributed object system, where HTML pages are considered as objects, having identify provided by URLs, and methods defined by, or that are invoked via, HTTP servers. The basic resemblance of the Web to a simple object system has created a natural interest in seeing how far the resemblance can be further developed.
  
• Object technology is seen as a particularly-convenient way of adding functionality (e.g., behavior) to the Web, both by adding the behavior provided by objects to the static content of HTML, and by allowing Web clients and servers, through distributed object technology, to access other computing resources. For example:
• Java can be added to Web pages and, once downloaded to the client, can then execute. In some cases, the client objects then interact with server objects, possibly using a different protocol, e.g., OMG's IIOP or Java's RMI.
• Web pages can be treated as objects or collections of objects for use by other code. Dynamic HTML developments by Microsoft and Netscape, and current World Wide Web Consortium (W3C) work on a Document Ob ject Model (see below), allow the contents of an HTML document to be treated as a collection of programmable objects. Client-side code can then access these objects and manipulate them dynamically (e.g., causing immediate changes in the document displayed to the user).

Such efforts all contribute toward giving the Web a richer structural base, capable of directly supporting a wider variety of activities, in more flexible and extensible ways. However, up until recently these efforts have still been based on HTML, with its basic structuring limitations, and have generally been pursued as separate, non-integrated activities. There is much other ongoing work within both the Web and database communities on data structure developments to address Web-related enhancements. Work on similar issues is ongoing within the Object Management Group as well. This work has contributed valuable ideas, and the various proposals illustrate similar basic concepts (generally, movement toward some form of object model). However, these similarities are often obscured by detailed representational differences, and the work is fragmented and lacks a unifying framework. As a result, individual proposals often lack key capabilities that are in some cases contained in other proposals. Moreover, in many cases these proposals are not well-integrated with key areas of emerging industry consensus on Web data structuring technologies.

If the Internet is to develop to support advanced application requirements, there is a need for both richer individual data structuring mechanisms, and a unifying overall framework which supports heterogeneous representations and extensibility and provides metalevel concepts for describing and integrating them.

We believe that a number of (in some respects) separate "threads" of development in the Web community can be combined to form the basis of a Web object model to address these requirements. This combination is based on the observation that the fundamental components of any object model are:

• data structures that can represent object state
• ways to associate behavior (object methods) with the object state
• ways for the object methods to access and operate on that state

Extending this idea to the Web environment, the idea is that Web pages can be considered as state, and objects can be constructed by enhancing those pages with additional metadata that allows the pages to be considered as objects in some object model. In particular, we want to enhance Web pages with metadata consisting of programs that act as object methods with respect to the "state" represented by the Web page.

As a result, what is needed to progress toward a Web object model is:

• a richer base representation than HTML, in order to better represent "object state" (in particular, provide better support for semantic identification of fields, rather than simply supporting the presentation aspects of text)
• an API to this state, so that programs can readily access it (without complex parsing)
• an enhanced ability to define relationships between this state and specified pieces of code that can serve as object methods, to provide an enhanced ability to compose objects from both existing and new Web resources

At the same time, the openness of the Web compared to conventional object models needs to be preserved, due to the distinct requirements of the Web environment for openness and scalability.

The key component technologies we have identified to support these requirements are:

• the Extensible Markup Language (XML) <http://www.w3.org/XML/>. XML provides a richer representation for object state than HTML, including both application-specific tagged data elements and nested structures, and more powerful linking facilities. In supporting an object model, XML pages (like HTML pages) can also be used as containers for embedded objects and object methods (e.g., Java applets).
• the Document Object Model (DOM) <http://www.w3.org/DOM/>. The DOM provides an API (currently defined using OMG's IDL) for XML documents used as object state, and provides a mechanism for integrating object state and associated code.
• mechanisms for representing and implementing embedded object methods, including:
• the OBJECT element from HTML 4.0 for representing and implementing embedded object methods
• arbitrary pieces of code defined as or within Web resources separate from the state (e.g., code libraries), identified by URLs, that are designed to access the state via its DOM-based interface, and that are associated with the state via the relationship mechanism mentioned in the next bullet
• concepts from the Platform for Internet Content Selection (PICS) <http://www.w3.org/PICS/> and Resource Description Framework (RDF) <http://www.w3.org/Metadata/RDF/> Web metadata models. These technologies provide standardized attributes, data structures, and infrastructure for representing and implementing basic aspects of an object model, including,
• relationships between documents containing state and documents containing metadata (including type information and code implementing object methods)
• a framework for accessing and invoking object methods contained in separate Web resources when documents requiring those methods are accessed
• type definitions and relationships between types (e.g., inheritance), depending on the details of the object model chosen

These same technologies can also play other valuable roles in distributed object architectures (for example, XML could be used as a serialization representation for moving objects within a network).

We have prepared a full technical report, "Towards a Web Object Model" <http://www.objs.com/OSA/wom.htm>, which:

• describes key examples of existing work from the Web, database, and OMG communities (including those mentioned above) that contribute both ideas and technology toward providing the components of a Web object model
• identifies some key underlying principles behind this work
• identifies a framework which allows this work to be unified and extended to support the requirements of advanced Web applications for object technology

A more complete integration of object technologies into the Web would provide the basis of both powerful capabilities for integrating all kinds of data and information, and a wide variety of enhanced services, within a distributed architecture that is both widely-available, and easy-to-use and extend.

References

[Bos97] J. Bosak, "XML, Java, and the Future of the Web" <http://sunsite.unc.edu/pub/sun-info/standards/xml/why/xmlapps/htm>, 1997.

[Sol95] R. Soley (ed.), Object Management Architecture Guide, Third Edition, Wiley, June 1995 <ftp://ftp.omg.org/pub/docs/ab/95-05-05.ps>.