1.  Field of the Invention
This invention relates to distributed computing environments including Web-centric and Internet-centric distributed computing environments, and more particularly to a heterogeneous distributed computing environment based upon a message passing model for connecting network clients and services. 
2.  Description of the Related Art
Intelligent devices are becoming more and more common.  Such devices range from smart appliances, personal digital assistants (PDAs), cell phones, lap top computers, desktop computers, workstations, mainframes; even, super computers.  Networks are also becoming an increasingly common way to interconnect intelligent devices so that they may communicate with one another.  However, there may be large differences in the computing power and storage capabilities of various intelligent devices.  Devices with more limited capabilities may be referred to as small footprint devices or “thin” devices.  Thin devices may not be able to participate in networks interconnecting more capable devices.  However, it may still be desirable to interconnect a wide variety of different types of intelligent devices. 
The desire to improve networking capabilities is ever increasing.  Business networks are expanding to include direct interaction with suppliers and customers.  Cellular phones, personal digital assistants and Internet-enabled computers are commonplace in both business and the home.  Home networks are available for interconnecting audio/visual equipment such as televisions and stereo equipment to home computers, and other devices to control intelligent systems such as security systems and temperature control thermostats.  High bandwidth mediums such as cable and ASDL enable improved services such as Internet access video on demand, e-commerce, etc.  Network systems are becoming pervasive.  Even without a formal network, it is still desirable for intelligent devices to be able to communicate with each other and share resources. 
Currently, traditional networks are complex to set up, expand and manage.  For example, adding hardware or software to a network often requires a network administrator to load drivers and configure systems.  Making small changes to a network configuration may require that the entire network be brought down for a period of time.  Also, certain intelligent devices may not support the necessary interfaces to communicate on a given network. 
What is needed is a simple way to connect various types of intelligent devices to allow for communication and sharing of resources while avoiding the interoperability and complex configuration problems existing in conventional networks.  Various technologies exist for improving the addition of devices to a network.  For example, many modern I/O buses, such as the Universal Serial Bus, 1394 and PCI, support plug and play or dynamic discovery protocols to simplify the addition of a new device on the bus.  However, these solutions are limited to specific peripheral buses and are not suitable for general networks. 
A more recent technology, Jini from Sun Microsystems, Inc., seeks to simplify the connection and sharing of devices such as printers and disk drives on a network.  A device that incorporates Jini may announce itself to the network, may provide some details about its capabilities, and may immediately become accessible to other devices on the network.  Jini allows for distributed computing where the capabilities of the various devices are shared on a network.  The Jini technology seeks to enable users to share services and resources over a network.  Another goal of the Jini technology is to provide users with easy access to resources anywhere on the network while allowing the network location of the user to change.  Jini also seeks to simplify the task of building, maintaining and altering a network of devices, software and users. 
Jini requires that each Jini enabled device has a certain amount of memory and processing power.  Typically, a Jini enabled device is equipped with a Java Virtual Machine (JVM).  Thus, Jini systems are Java technology centered.  Java is a high level object oriented programming language developed by Sun Microsystems, Inc. Java source code may be compiled into a format called bytecode, which may then be executed by a Java Virtual Machine.  Since Java Virtual Machines may be provided for most computing platforms, Java and thus Jini provide for a certain amount of platform independence.  The Jini architecture leverages off the assumption that the Java programming language is the implementation language for the components of the Jini system.  The ability to dynamically download and run Java code is central to many features of the Jini architecture. 
The purpose of the Jini architecture is to federate groups of devices and software components into a single dynamic distributed system.  A key concept within the Jini architecture is that of a service.  A service is an entity that can be used by a person, a program, or another service.  Two examples of services are printing a document and translating from one word processor format to another.  Jini allows the members of a Jini system to share access to services.  Services in a Jini system communicate with each other by using a service protocol, which is a set of interfaces written in the Java programming language.  Services are found and resolved in a Jini system by a look-up service.  A look-up service maps interfaces indicating the functionality provided by a service to sets of objects that implement the service. 
Descriptive entries may also be associated with a service.  Devices and applications use a process known as discovery to register with the Jini network.  Once registered, the device or application places itself in the look-up service.  The look-up service may store not only pointers to these services on the network, but also may store the code for accessing these services.  For example, when a printer registers with the look-up service, it loads its printer driver and/or an interface to the driver into the look-up service.  When a client wants to use the printer, the driver and driver interface get downloaded from the look-up service to the client.  This code mobility means that clients can take advantage of services from the network without pre-installing or loading drivers or other software. 
Communication between services in a Jini system is accomplished using the Java Remote Method Invocation (RMI).  RMI is a Java programming language enabled extension to traditional remote procedure call mechanisms.  RMI allows not only data to be passed from object to object around the Jini network, but full objects including code as well.  Jini systems depend upon this ability to move code around the network in a form that is encapsulated as a Java object. 
Access to services in a Jini system is lease based.  A lease is a grant of guaranteed access over a time.  Each lease is negotiated between the user of the service and the provider of the service as part of the service protocol.  A service may be requested for some period and access may be granted for some period presumably considering the request period.  Leases must be renewed for a service to remain part of the Jini system. 
FIG.  1 illustrates the basic Jini technology stack.  The Jini technology defines a distributed programming model 12 (supported by JavaSpaces, leases, and object templates).  Object communication in Jini is based on an RMI layer 14 over a TCP/IP capable networking layer 16. 
Jini is a promising technology for simplifying distributed computing.  However, for certain types of devices, Jini may not be appropriate.  The computing landscape is moving toward a distributed, Web-centric service and content model where the composition of client services and content changes rapidly.  The client of the future may be a companion type device that users take with them wherever they go.  Such a device may be a combination of a cell phone and a PDA for example.  It would be desirable for such devices to be able to communicate and share resources with more powerful devices as well as thinner or less powerful devices. 
Also, with the advent of the Internet and resulting explosion of devices connected to the net, a distributed programming model designed to leverage this phenomenon is needed.  An enabling technology is needed that facilitates clients connecting to services in a reliable and secure fashion.  Various clients from thick to thin and services need to be connected over the Internet, corporate Internets, or even within single computers.  It is desirable to abstract the distance, latency and implementation from both clients and services. 
The key challenge for distributed computing technology is to be scalable from powerful thick clients down to very thin clients such as embedded mobile devices.  Current distributed computing technologies, such as Jini, may not be scalable enough for the needs of all types of clients.  Some devices, such as small footprint devices or embedded devices, may lack sufficient memory resources and/or lack sufficient networking bandwidth to participate satisfactorily in current distributed computing technologies.  The low end of the client spectrum, including embedded mobile devices, often have limited or fixed code execution environments.  These devices also may have minimal or no persistent storage capabilities.  Most small, embedded mobile devices do not support a Java Virtual Machine.  Most code-capable small clients run native code only.  Also, most small devices have little more than flash memory or battery backed RAM as their sole persistent storage media.  The size of the storage is often very small and sometimes read-only in nature.  Furthermore, the access time of this type of storage media is often an order of magnitude greater than hard disk access time in more powerful clients. 
Existing connection technologies, such as Jini, may not be as scalable as desired because they are too big.  For example, Jini requires that all participants support Java; however, many small clients may not have the resources for a Java Virtual Machine.  Furthermore, due to its use of RMI, Jini requires that clients be able to download code and content.  Jini may augment the existing client platform by downloading new classes, which may pose security and size concerns for small devices such as embedded devices.  Jini works by clients and resources communicating by passing code and data.  When a client activates a Jini service, the service may return its results to the client, which may include a large amount of code or content.  In Jini, a client may call a method and a large object may be returned, and thus downloaded.  The client may not have the resource to accept the returned object.  Also, RMI and Java itself require a lot of memory.  Many small foot print devices may not have the resources to participate effectively or at all in current distributed computing technologies. 
Another concern with existing distributed computing technologies is that they often require certain levels of connection capability and protocols.  For example, Jini assumes the existence of a network of reasonable speed for connecting computers and devices.  Jini also requires devices to support TCP/IP network transport protocol.  However, many smaller devices may have limited connection capabilities.  Small devices may have high latency or low speed network connections and may not support TCP/IP. 
As mentioned above, Jini requires devices to support Java and thus include a Java Virtual Machine, which requires a certain amount of processing and storage capabilities that might not be present for many small devices.  This also restricts the flexibility of Jini in that non-Java devices may not directly participate in a Jini system.  Since Jini requires Java, it may be deemed a homogenous environment.  However, it is desirable to have a distributed computing facility for heterogeneous distributed computing that scales from extremely small embedded devices through PDA's and cell phones to laptops and beyond even to the most powerful computers. 
Other heterogeneous solutions exist, such as the Common Object Request Broker Architecture (CORBA).  CORBA is an architecture that enables program objects to communicate with one another regardless of the programming language they were written in or what operating system they're running on.  However, CORBA does not address all of the connection issues that are addressed by Jini.  Also, CORBA suffers from similar scalability problems as Jini. 
Technology such as Jini and CORBA use a code-centric programming model to define the interface between remote components.  A code-centric programming model defines programmatic interfaces or API's for communication between remote clients or components.  The API's may be defined in a particular programming language.  The API's must be agreed to by all software components to ensure proper interoperability.  Since all access to components is through the use of these standards API's, the code that implements these API's must be present in the client platform.  The code may be statically linked into the platform or dynamically downloaded when needed.  Many embedded or mobile devices simply cannot accept code dynamically from a network due to the quality control issues involved as well as the reliance on a single language and program execution environment.  Data-centric models, such as networking protocols, may avoid the dependence on moving code; however, such protocols are not rich enough to easily provide for distributed computing and they also lack the ease of programming with code and other programming features, such as type safety. 
Conventional distributed computing systems rely on the ability of a program executing on a first device to be able to remotely call a program on a second device and have the results returned to the first device.  The Remote Procedure Call (RPC) is a basic mechanism for remotely calling a program or procedure.  CORBA and Jini are both based on the ability to remotely invoke program methods.  However, communicating by passing code or objects, such as in Jini or CORBA, may be somewhat complex.  For example, as mentioned above, Jini uses the Java Remote Method Invocation (RMI) to communicate between services.  In order for a client to move Java objects to and from remote locations, some means of serialization/deserialization is needed.  Such current facilities in the Java Development Kit (JDK) rely upon the reflection API to determine the content of a Java object, and ultimately that code must consult the Virtual Machine.  This code is quite large and inefficient. 
The fundamental problems with the current method for doing serialization/deserialization include its size, speed, and object traversal model.  Code outside the JVM does not know the structure or graph of a Java object and thus must traverse the object graph, pulling it apart, and ultimately must call upon the JVM.  Traditional serialization and reflection mechanisms for storing and moving Java objects are just not practical for all types of devices, especially thinner devices.  Some of the difficulties with Java reflection and serialization are that an object's graph (an object's transitive closure) reflection is difficult to do outside the JVM.  Serialization is too large, requiring a large amount of code.  Also, serialization is a Java specific object interchange format and thus may not be used with non-Java devices. 
The Jini distributed computing model requires the movement of Java objects between Java devices.  Thus, the serialization mechanism itself is not platform independent since it may not be used by non-Java platforms to send and receive objects.  Serialization is a homogenous object format —it only works on Java platforms.  Serialization uses the reflection API and may be limited by security concerns, which often must be addressed using native JVM dependent methods.  The reflection API may provide a graph of objects, but is inefficient due to the number of calls between the JVM and the code calling the reflection methods. 
The use of Java reflection to serialize an object requires an application to ping pong in and out of the JVM to pick apart an object one field at a time as the transitive closure of the object is dynamically analyzed.  Deserializing an object using Java deserialization requires the application to work closely with the JVM to reconstitute the object one field at a time as the transitive closure of the object is dynamically analyzed.  Thus, Java serialization deserialization is slow and cumbersome while also requiring large amounts of application and JVM code as well as persistent storage space. 
Even for thin clients that do support Java, the Jini RMI may not be practical for thin clients with minimal memory footprints and minimal bandwidth.  The serialization associated with the Jini RMI is slow, big, requires the JVM reflection API, and is a Java specific object representation.  Java deserialization is also slow, big and requires a serialized-object parser.  Even Java based thin clients may not be able to accept huge Java objects (along with needed classes) being returned (necessarily) across the network to the client as required in Jini.  A more scalable distributed computing mechanism is needed.  It may be desirable for a more scalable distributed computing mechanism to address security concerns and be expandable to allow for the passing of objects, such as Java objects, and even to allow for process migration from one network mode to another. 
Object based distributed computing systems need persistent storage.  However, as discussed above, attempts at object storage are often language and operating system specific.  In addition, these object storage systems are too complicated to be used with many small, embedded systems.  For example, the Jini technology uses JavaSpaces as persistent object containers.  However, a JavaSpace can only store Java objects and cannot be implemented in small devices.  Each object in a JavaSpace is serialized and pays the above-described penalties associated with Java serialization.  It may be desirable to have a heterogeneous object repository for distributed computing that may scale from small to large devices. 
JavaSpaces from Sun Microsystems, Inc., draws from the parallel processing work of David Gelernter, a computer science professor at Yale University.  Gelernter's set of functions named “Linda” create a shared memory space called a TupleSpace, in which results of a computer's processes or the processes themselves may be stored for access by multiple CPUs.  Linda therefore provides a global shared memory for multiple processors. 
Another technology which extends Linda is TSpaces from IBM Corporation.  TSpaces extends the basic Linda TupleSpace framework with real data management and the ability to download new datatypes and new semantic functionality.  TSpaces provides a set of network communication buffers and a set of APIs for accessing those buffers.  Like many of the solutions discussed above, TSpaces therefore uses a code-centric programming model and shares the drawbacks of such a model.  Additionally, TSpaces is implemented in the Java programming language and therefore requires a Java Virtual Machine or other means of executing Java bytecode, such as a Java-capable microprocessor.  Therefore, TSpaces may be inappropriate for small-footprint devices which cannot devote sufficient resources for executing Java bytecode. 
It is desirable in object oriented distributed systems to be able to locate object repositories and find particular objects within those repositories.  As mentioned above, the Jini look-up server may not be practical for small devices with small memory footprints.  A more efficient mechanism for locating object stores may be desirable. 
Distributed object access also desires a fair and efficient sharing mechanism.  As described above Jini currently uses a leasing mechanism to share objects.  However, Jini leases are time based which may result in a number of problems.  For example, the current object holder might have no idea how long to lease an object and may hold it too long.  Also, the use of time-based leases may require that time be synchronized between multiple machines.  Moreover time based leasing may require operating system support.  Also, Jini leases are established and released via RMI.  Thus, the Jini leasing mechanism suffers from the above-noted problems with using RMI.  Other leasing mechanisms may be desirable. 
Generally speaking, it is desirable for small memory foot print mobile client devices to be able to run a variety of services, both legacy and new, in a distributed environment.  The types of small clients may include cell phones and PDA's with a variety of different networking interfaces, typically low bandwidth.  Often these devices have very small displays with limited graphics, but they could include laptops and notebook computers, which may have a larger display and more sophisticated graphics capabilities.  The services may be a wide range of applications as well as control programs for devices such as printers.  It is desirable for a mobile client to be able to use these services wherever they may be. 
A mobile client will often be at a temporary dynamic network address, so networking messages it sends cannot be routed beyond that networking interface (otherwise there may be collisions when two different clients on different networks have the same dynamic address).  Mobile clients often do not have the capability for a full function browser or other sophisticated software.  The displays may limit the client from running certain applications.  Traditional application models are based on predetermined user interface or data characteristics.  Any change to the application requires recompilation of the application. 
It may be desirable for such clients to have a mechanism for finding and invoking distributed applications or services.  The client may need to be able to run even large legacy applications which could not possibly fit in the client's memory footprint.  As discussed above, current technology, such as Jini, may not be practical for small footprint devices.  The pervasiveness of mobile thin clients may also raise additional needs.  For example, it may be desirable to locate services based on the physical location of the user and his mobile client.  For example, information about the services in a local vicinity may be very helpful, such as local restaurants, weather, traffic maps and movie info. 
A distributed computing model should provide clients with a way to find transient documents and services.  It may be desirable to have a mechanism for finding general-purpose documents (including services and/or service advertisements), where the documents are expressed in a platform-independent and language-independent typing such as that provided by eXtensible Markup Language (XML).  Current approaches, including lookup mechanisms for Jini, Universal Plug and Play (UPnP), and the Service Location Protocol (SLP), do not support such a general-purpose document lookup mechanism.  For example, the Jini lookup mechanism is limited to Java Language typing and is therefore not language-independent.  UPnP and SLP support a discovery protocol only for services, not for general-purpose documents. 
Similarly, information about computing resources, such as printers in a particular location, may be helpful.  Current technologies do not provide an automatic mechanism for locating services based on physical location of the client.  Another need raised by thin mobile clients is that of addressing the human factor.  Thin mobile clients typically do not contain ergonomic keyboards and monitors.  The provision of such human factor services and/or the ability to locate such services in a distributed computing environment may be desirable.