Trading-Based Composition for Component-Based Systems

The web, as it transitions from documents to programs, needs to provide infrastructural support for distributed computing. Programs that operate on the web computer (i.e. treat the web as a virtual machine) need capabilities beyond the information retrieval mechanisms currently provided by web infrastructures. Distributed web applications are likely to be composed of a large number of components that are globally distributed, and richly connected by  various kinds of bindings. Current examples of such applications include virtual scientific experiments (e.g. Caltech Infospheres) and distributed sensing experiments. In a sense, this distributed web application architecture is the same as that of current distributed object (CORBA, COM etc.) applications, only amplified by the greater number of components and bindings involved. Current web computing is based on direct forms of addressing such as URLs, and static binding mechanisms between components (e.g. CGI-URLs and direct applet-applet communication schemes).  A system that is composed of statically bound components is brittle, hard to assemble,  and potentially inefficient. Web computing can benefit from an infrastructure that facilitates the dynamic composition of components to constitute larger applications.

Trading provides a simple, widely used paradigm that can facilitate web computing. In a trader-based architecture, a client component that requires a particular service can query an intelligent matchmaking agent called a trader, for handles to available components that provide the desired kind of service. The client component then dynamically binds to the server whose handle is returned by the trader.  Service components make themselves known to the trader by publishing their capabilities to the trader. Traders are analogous to search engines, except that they are specialized to help programs discover other programs rather than for people to discover information.

The benefits of traders in component-based architectures can be motivated by analogy to how search engines benefit people. If every person had a home page, then I could discover people similar to myself by querying Yahoo for home pages with similar keywords to those that occur in my page. By analogy,  smart services  can discover other instances of  similar services by querying the trader for similar service descriptions. Using the service discovery capability that a trader provides a  smart service can be self-federating. For example, an annotation server (i.e. provider of annotation services on the web) could use trading to discover and bind to other similar annotation servers (e.g. those providing a different community's annotations on the URL that is requested by the client) without the annotation client being aware of how many annotation servers are cooperating behind the scenes to compose the annotated content.

Dynamic bindings established by trading can also be used to build resilient, adaptable and context-aware applications.  Relative motion between a component and another may require that bindings be periodically re-established.  In the mobile computing case, physical movement of a component may make it necessary to reinstantiate some bindings. For example, a binding between a mobile component and the nearest postscript print service will change as the component (and the PC on which it resides) moves.  Trading can be part of a context-aware system architecture, in which the system is aware of the context of a particular binding, and the periodic need to reinstantiate the binding. Internet weather (i.e. dynamically changing performance of different parts of the internet) may require that a component break the binding to a slow service, and rebind to a similar service in a higher performance part of the network.

Trader-based architectures are a fairly large design space, catering to a variety of applications. Reference Model for trading-based distributed systems architectures elaborates on the design space,  parts of the space explored by ongoing and past projects, and related OMG/ISO standards activities. The challenge in web-based trading is to pick a point in this design space that is compatible with the philosophy and implementation of the web. In other words, a lightweight trader design that leverages off web technologies and can scale up to large distributed web applications. Web technologies such as search engines, XML, PEP and Java provide promising component technologies to build traders. XML provides services with a fairly rich vocabulary in which to express their capabilities and characteristics to a trader. Search engines provide the ability to store service offer information and to query it, thus obviating the need to build a proprietary publish/subscribe capability. PEP and other HTTP mechanisms could be used to implement complex and stateful communication between different components in a trader-based system. These and other web technologies can be used to inject trading function into ongoing web computing in a transparent fashion. My current work focusses on building such as a  web trading implementation specifically for the smart service for web annotation, and more generally to cater to adaptable, context-aware computing.