The Cover PagesThe OASIS Cover Pages: The Online Resource for Markup Language Technologies
Advanced Search
Site Map
CP RSS Channel
Contact Us
Sponsoring CP
About Our Sponsors

Cover Stories
Articles & Papers
Press Releases

XML Query

XML Applications
General Apps
Government Apps
Academic Apps

Technology and Society
Tech Topics
Related Standards
Last modified: October 11, 2002
Tuple Spaces and XML Spaces

[March 15, 2002] A hastily-collected pile of raw cribbings from the Net on "XML tuple spaces" and congeners. Provisional and not officially maintained. Request communication from someone who has done this properly. -rcc


The Crudlet Project. Crudlet is an event based architecture for connecting XML based interface structures to Jini service layers. The Crudlet Architecture can be used simply as a traditional application server engine that links a database to a web front end, or anything through to a fully distributed exchange system that utilizes auto generated Java servlets and an ensemble of Jini services to provide content sharing and middleware messaging. The Java package org.crudlet.* provides a collection of events, expressed as XML tags, that map to the JavaSpaces interface. Put simply, data is moved is moved back and forth between the XML based front end and the Jini back end through a series of events. Each event executes the business logic contained on the java bean for each component as it is passed backward to the javaspace. The information is then returned, along with an error structure to the user interface. Crudlet's purity of separation of powers between the front end design layer (XSL/XML) the business logic layer (JavaBeans), the backend messagimg layer (JavaSpace and agents) and database layer (JDBC) provides several advantages over other application server architectures.


JavaSpaces from Sun. JavaSpaces technology is a simple unified mechanism for dynamic communication, coordination, and sharing of objects between Java technology-based network resources like clients and servers. In a distributed application, JavaSpaces technology acts as a virtual space between providers and requestors of network resources or objects. This allows participants in a distributed solution to exchange tasks, requests, and information in the form of Java technology-based objects. JavaSpaces technology provides developers with the ability to create and store objects with persistence, which allows for process integrity. The JavaSpaces technology is written in the Java language, and is a Jini technology service. It is a simple, fast, and unified mechanism for sharing, coordinating, and communicating distributed resources, services, and objects across a network. This technology is best used when for creating new services in a networked application... See JavaSpaces Service Specification. Version 1.1. October 2000. "The JavaSpaces service specification provides a distributed persistence and object exchange mechanism for code written in the JavaTM programming language. Objects are written in entries that provide a typed grouping of relevant fields. Clients can perform simple operations on a JavaSpaces service to write new entries, lookup existing entries, and remove entries from the space. Using these tools, you can write systems to store state, and also write systems that use flow of data to implement distributed algorithms and let the JavaSpaces service implement distributed persistence for you. See also the FAQ document, the book, and web site.


Project 'jxtaspaces'. A Distributed Shared Memory Service for JXTA. "jxtaSpaces is an experimental project to design and implement a distributed shared memory service on the JXTA peer-to-peer computing platform. Generative Communication Model: Distributed shared memory is a model for inter-process communication that provides the illusion of a shared memory on top of a message passing system. Programming distributed applications using a shared memory abstraction is less complex than explicitly using message passing. In addition, the DSM model allows communicating processes to be uncoupled logically, temporally, and spatially. A well-known software implementation of distributed shared memory is the generative communication model, best represented by the Linda coordination language for parallel computing. In this model, processes share a virtual memory space called a tuplespace. The fundamental data unit, a tuple, is an ordered vector of typed values. Processes communicate by reading, writing, and consuming these tuples. Another distinguishing feature of tuplespaces is that tuples are accessed associatively, that is, by their contents rather than by their addresses. A simple set of familiar operations allows highly complex communication and synchronization schemes to be constructed using this model. The tuplespace model for distributed programming has recently seen an increase in popularity, with commercial systems in Java available from Sun (JavaSpaces), IBM (TSpaces), and others. These products differ from (and improve upon) the original Linda system in various ways, most notably by being object-oriented and not requiring language extensions or a special compiler. Distributed Tuplespaces: Most tuplespace systems assume one or more spaces running on one or more processors; however, the notion of distributing a single space over multiple processors is less common. Sun's JavaSpaces, for example, supports multiple local and remote shared spaces, but does not explicitly support distributed spaces. IBM's TSpaces has similar limitations. True distributed spaces offer many advantages, in particular scalability and availability. jxtaSpaces intends to provide scalable shared memory services for networks of heterogeneous peers. In large peer-to-peer networks, a global shared memory can be used in many ways to simplify the building of complex distributed applications..."


Linda. "The Linda Group, part of the Programming Languages and Software Systems group in the Department of Computer Science, Yale University, explores a variety of research topics in parallel and distributed computing, adaptive computation, parallel programming languages, groupware and information systems. Much of this work centers around the Linda programming language or ideas that have been spawned from work on the Linda system." See references.


MARS enables agents to coordinate with other entities they encounter in thier nomadic life. It is not another MAS, but it works in conjunction with a MAS, such as Java-To-Go, or Odyssey. MARS implements a coordination architecture based on Linda-like tuple spaces, associated to each execution environment, where agents can store and retrieve messages in a spatial and temporal uncoupled way. In addition, MARS is programmable, i.e. agents can associate reactions to the operations made on the space. Programmability of tuple spaces leads to more flexible and secure interactions... MARS is implemented in Java, and can be connected to Java-based MAS. MARS follows the specifications of JavaSpace. The tuples are Java objects, and agents retrieve/store them by using Linda-like operations, sunch as: (1) read - reads a tuple from the space; (2) take - reads and deletes a tuple from the space; (3) write - stores a tuple in the space. The tuples are retrieved by an object-oriented associative mechanism. Reactions are stored as tuples in a meta-level tuple space. Putting and extracting tuples from the meta-level tuple space means installing and de-installing reactions... The MARS package comes with a very easy to use graphical interface with which you can write tuples into the local tuple space, install and de-install reaction, launch agents. The Interface consists of Java applets, we can be easily adapted to provide Web access to MARS administration."


PyBrenda: "PyBrenda is a simple library for doing parallel processing in Python... PyBrenda is a parallel computing tool modelled on C-Linda. Use it to schedule tasks on multiple processors... PyBrenda is a system for easily doing parallel computation using the Python programming language. It is somewhat similar to the C-Linda language; it uses the notion of "tuple space" to simplify the interactions among processes. PyBrenda coordinates requests for more processors to be involved in computations and facilitates data sharing among those processors... PyBrenda only runs on UNIX systems." Download PyBrenda 0.4.1 (UNIX). Contact: Milton L. Hankins. See website; [sources]

Rowston: Linda/Bonita

Antony Rowstron: Bonita and WCL. Home page and papers. From "Tuple space base coordination languages: beyond Linda." "I have been interested in tuple space based coordination languages for the last 6 years (as in Linda). My interests have covered the studying of the limitation of existing tuple space based languages, the development of new tuple space based coordination languages and primitives to overcome these limitations, the development of run-time systems that support tuple space based languages, and the development of alternative techniques to provide support for open tuple space languages. My interest in coordination languages was ignited whilst doing a PhD in the Linda Group at the University of York, UK... I have developed two tuple space coordination languages, called Bonita and WCL and have also worked on the development of several new primitives for Linda. One of the most interesting primitives was a primitive called copy-collect which overcame the multiple rd problem. The multiple rd problem is based on the problem of having multiple concurrent readers of a set of tuples. The primitive was an extension of the collect primitive (also developed at York), and uses multiple tuple spaces... Bonita was developed in an attempt to overcome the problems of high latency in tuple space based coordination languages. The standard Linda primitives provide asynchronous inter-process communication, but provide synchronous communication with a tuple space. Bonita was developed to provide only asynchronous access to a tuple space. Therefore, an in is decomposed into a request for a tuple, and a receive tuple. The language provided primitives to check if a result was available and to block until a result tuple is available. This means that not only do you get the asynchronous tuple space access, but you also can mimic the traditional Linda primitives. This proved to be very powerful providing easy parallel tuple space access from a single process, and the ability to request multiple tuples and then act on them as they actually arrive. Also, it allows a form of inp primitive, which does not potentially hammer the run-time..."

Ruple: Rogue Wave Software

News item content from 2002-03-01:

A posting from Andy Gray announces the Alpha Version 2 release of Ruple, implementing XML Spaces. Ruple is an Internet space (similar to Sun 'JavaSpaces' and IBM 'Tspaces') based upon tuple space architecture; it is implemented "as a distributed collection of content-addressable documents, providing a shared memory space for multiple applications from which documents can be read or to which documents can be written. It supports asynchronous Web services, secure document exchange, application integration and coordination, occasionally connected devices, and peer-to-peer computing. Like other spaces, Ruple allows synchronization of highly decoupled systems, but it is unique in that it both stores XML (Extensible Markup Language) documents, and that it is accessible over the Internet using standard Internet protocols such as HTTP and the Simple Object Access Protocol (SOAP). In addition, it offers a security model based on X.509 digital certificates, allowing only those with the proper security to place and take documents in a Ruple space. Ruple natively stores XML documents, and retrieves them using an XML query syntax." New features in the Ruple Alpha V2 release include MIME-based attachments,a server-side download, and comprehensive examples illustrating the use of Ruple technology.

"Ruple is a distributed computing technology built on an Internet tuple space for XML documents, providing a loosely coupled asynchronous and anonymous link between multiple senders and receivers. Ruple provides a foundation for asynchronous, loosely coupled, XML document exchange, allowing for collaborating applications while radically decoupling senders and receivers... Ruple, Sun's JavaSpaces and IBM's Tspaces share a foundation based on tuple space architecture. However, Java tuple space implementations differ from Ruple in that they are object-centric. In contrast, Ruple stores and returns documents. JavaSpaces and TSpaces store and exchange Java objects, relegating their utility to Java-only environments and closely tying them to a programming language or language-specific object model."

From the post: "Ruple technology can be applied to a number of communication challenges, including asynchronous Web services, secure document exchange, application integration and coordination, occasionally connected devices, and peer-to-peer computing... Ruple facilitates secure XML document exchange over the Internet or private networks; its key technical attributes include asynchrony, security, flexible document exchange, identity-based addressing and simplicity. New features in this latest release include:

  • MIME-based attachments, allowing you to attach binary files to XML documents.
  • A server-side download, letting you host your own space instead of using the Rogue Wave forum.
  • Comprehensive examples, illustrating the use of Ruple technology in a number of scenarios.

From the white paper: "Ruple is an Internet based space. As such, it is a distributed collection of content-addressable documents, providing a shared memory space for multiple applications from which documents can be read or to which documents can be written. Like other spaces, it allows synchronization of highly decoupled systems, but it is unique in that it both stores XML (eXtensible Markup Language) documents, and that it is accessible over the Internet using standard Internet protocols such as HTTP and the Simple Object Access Protocol (SOAP). In addition, it offers a security model based on X.509 digital certificates, allowing only those with the proper security to place and take documents in a Ruple space -- essential for working over the insecure Internet... Ruple provides a foundation for applications to collaborate transparently and independently by selectively and securely sharing documents over the existing Internet infrastructure and technology. By leveraging a simple, SOAP-based interface for reading and writing documents to and from the space, implementing reads based on content instead of physical address, and building on document-level security, Ruple is a first step in fulfilling the great promise of the Internet for collaborative business applications. The space supported by Ruple is called the Ruple Forum (or Forum for short). A simple set of atomic instructions can place documents or access existing ones by using a query based on a subset of the XML Query Language (XQL)... While Ruple shares many attributes with other spaces, it differs in one important respect: it natively stores XML documents and then retrieves them using an XML query syntax. This is an important distinction. Traditional tuple space implementations have been closely tied to a programming language or language-specific object model. The object-centric approach has limited utility on the Internet and in heterogeneous environments as it ties developers to a particular programming language and binary protocol. In contrast, Ruple's document-centric approach is independent of any particular programming language, offering the choice of processing the document or a document fragment with the tools at hand, depending on your chosen language or environment. Ruple extends the notion of what constitutes a 'tuple' in that it supports any well-formed XML document or fragment, taking tuples out of the realm of academic possibilities, into the truly practical. Well-formed XML must be syntactically correct according to the XML 1.0 specification; however, the Forum does not require that documents be valid per any particular XML schema. This allows for the exchange of arbitrary documents through the space without having to configure the space for a new document type, allowing for ad hoc and flexible interactions. If document validity is important to the participants in a transaction then the collaborators may validate the document when they receive it..."

What are 'XML Spaces'? "XML Spaces is a new communication paradigm that brings together tuple spaces, XML, the Internet, security and Web services to create a simple yet powerful substrate for rich document exchange. XML Spaces extends the Web services model with looser coupling, abstract addressing, asynchrony, arbitrary XML support, many-to-many interactions and document-level security. XML Spaces supports ad-hoc collaboration seamlessly within an organization or across the Internet. Examine the technology and describe how it can be applied to a wide variety of applications." NextWareExpo Presentation 'Beyond Web Services: XML Spaces', by Andrew Gray.

Patrick Thompson on XML-DEV October 14, 2001: "Yes, you can put XML into a TSpace and get it out again. However, the interaction with TSpaces is object-centric rather than document-centric, and that is the distinction I am drawing. What you get back from a TSpace XML query is a tuple tree. You navigate the resulting (DOM-analogous) tuple object hierarchy to access the nodes of the result document. In a document-centric tuple spaces approach you aren't bound to an object model. Predictating an object model, in all practicality, ties you to a particular programming language and binary protocol. In contrast, the document-centric tuple space approach allows you the choice of processing the document (or not) with the tools at your disposal, depending on your language, environment, or liking. This and the loose-coupling, asynchronous, and 1-to-many interaction qualities of tuple spaces makes the document-centric XML tuple spaces approach an ideal foundation for distributed applications on the Internet..."

Patrick Thompson: Rogue Wave has direct experience of this. We created an XML tuple space implementation as the basis of a bid-ask marketplace (an e-procurement application). It worked beautifully. We found the simplicity, time/space decoupling, and multicast-like quality of the tuple spaces model ideal for document-centric interactions over the internet..."

Ruple Discussed: XML-DEV Thread 2001-11/2001-12

Commments of Gavin Thomas Nicol, Mike Champion, and Don Park from XML-DEV. See the thread.

Gavin Thomas Nicol on Ruple: "Part of my background is in distributed systems (hypermedia/workgroup systems)... so I'm speaking somewhat from experience. There are some problems (Sean's XGrid) where the Linda-like model works well. These tend to be compute-intensive, and/or parallel problems... and they require a degree of skill to develop program for (certainly a mentality). One way or another, Ruple adds little to traditional tuples-spaces (noting that tuple-spaces can vastly simplify some applications as compared to PVM et al.)... We've had SGML/XML repositories for years (about 6 or so), and while NXDB's are a key component for some things they are not themselves a killer application. My questions are "where's the killer app?" and "what's the ROI?". There are a lot of applications that probably could benefit from a Linda-esque model because synchronicity isn't needed, but these do not need Ruple spaces per se... For some applications, I agree that tuple-spaces could be useful. Whether you need/want Ruple for that is a different matter... Seems to me that "Ruple" is pretty trivial to implement given a reasonable underlying database. I'm not sure what the real value is though... how do you imagine such spaces being used? Perhaps for service lookup in web service registries? You should read the book "Mirror Worlds" and visit the company ( or You can also visit the Linda web site

Mike Champion. This technology seems a lot similar to "Java Spaces" at the first look.. Definitely, because they're both based on David Gelertner's original idea of "tuple spaces". As I understand it (and I just started reading the Sun JavaSpaces book!) JavaSpaces and TSpaces exchange Java objects; JavaSpaces uses Jini as the transport layer. Ruple and other "XML spaces" systems exchange small XML documents, providing application independence, platform independence, and vendor neutrality while leveraging HTTP/SMTP/FTP/etc as well as XPath, SOAP and other XML techologies. The RogueWave whitepaper discusses the comparison explicitly, and it's also brought out in an article one of their developers wrote at ... I (and I suspect the RogueWave and JXTA-spaces people as well) would completely agree that any XML "spaces" solution must either be layered on HTTP/WebDAV or have an HTTP binding to have any chance at success. JavaSpaces dependence on Jini was almost certainly the largest nail in its coffin. [I'd also assert that it's reliance on strong typing makes it less useful in a loosely coupled environment than Linda or Ruple, but that's another thread :~) ] ... I think of the various XML spaces as being at the layer above SOAP -- they provide an additional layer of services that doesn't come for free in HTTP or SOAP, and a Linda-like coordination protocol would have about the same architectural relationship to SOAP as RPC has. Specifically, the various "spaces" implementations offer the basic read/GET and write/PUT operations that HTTP does..."

Don Park: What drew me to Linda almost 20 years ago was the simple idea of using indirection to coordinate parallel programs. With advent of Internet, Linda is finding new application: coordination of distributed processes. The concept of tuple space has been reinterpreted in context of XML so that a tuple is an XML document with some aspects of the document used as tuple data and rest as payload. While XML-based Linda service network can be used for SOAP service lookup, I would go one step further so that SOAP invocations and results become tuples, thus removing the need for SOAP consumers to find providers entirely: you send SOAP invocation to Linda and wait for result to 'bubble' without being concerned about who provided the service (billing layer will of course have to exists for commercial services). Throw Linda, XML, and P2P in together and you end up with something more potent than sum of all the alphabets..."


TSpaces from IBM "is a set of network communication buffers called tuple spaces and a set of APIs (and classes that implement the API) for accessing those buffers. TSpaces allows heterogeneous, Java-enabled devices to exchange data with little programming effort. The package includes server software that implements the buffers and client software for accessing the buffers. TSpaces provides group communication services, database services, URL-based file transfer services, and event notification services. With its small footprint, it is ideal for bringing network services to small and embedded systems; for example, it brings the power of the network to palm devices, making them full-fledged network computers capable of controlling printers and other networked devices. For the client, being connected to TSpaces is like having the perfect assistant: TSpaces acts as a reminder service, carries out any tasks that you assign to it, reports incoming messages and delivers outgoing messages, and notifies you of any events in which you're interested. By adding additional client applications, TSpaces can be used as a universal print service, email service, pager service, remote control service, and so on. See also from Almaden: "TSpaces represents a breakthrough in communication middleware because it has combined sophisticated database functionality with communication middleware to create the first instance of an Intelligent Connectionware component." And publications/presentations, including Intelligent Connectionware: TSpaces.

See also: "IBM Releases TSpaces Services Suite."


  • References on distributed tuplespaces from JXTA

  • [October 11, 2002] "Exchanging Documents in XML Tuple Spaces." By Hans Hartman. In Seybold Report: Analyzing Publishing Technology [ISSN: 1533-9211] Volume 2, Number 13 (October 14, 2002). ['If Rogue Wave is right, what was once just an academic concept may become a mechanism for exchanging XML documents in ways that are simpler and more powerful than Web services.'] "A tuple space is a bit of shared storage -- a block of RAM, a database, a remote server -- that stores data in ordered lists called 'tuples.' The tuples have just a few key properties: (1) They can be accessed concurrently by several external applications. As with other ways of organizing data, the host system must guarantee that the tuples are completely written or removed from a space. (2) They are persistent, remaining available long after the application that created them has gone on to other tasks. (3) They do not have names or other external identifiers and are stored in no particular order. Instead, they are located by querying their content... There are already a few implementations. Tuple spaces have been developed for various programming languages, including Python, Linda and Java. Both Sun Microsystems (through JavaSpaces) and IBM (Tspaces) have developed tuple spaces for communication between Java objects... Rogue Wave Software has taken the idea of loosely coupling applications a step further by combining the notion of tuple spaces with that of self-describing XML documents... Rogue Wave's underlying philosophy is to keep the XML tuple-space system simple and flexible. Rogue Wave's product, called Ruple, has only four types of instructions: (1) Write: create a new document, specifying an access control list and an expiration date. (2) Read: issue an XQL query and read the first document that matches. (3) ReadMultiple: read all documents from the space that match an XQL query (up to a specified maximum). (4) Take: read and remove a document that matches an XQL query. Simple as they are, these four commands can support a rich assortment of document exchanges. In Ruple, XML documents are written to the space for a limited time period, allowing applications to use them on a 'leasing' basis. The company is also considering adding some type of messaging mechanism to notify partners when new documents are placed in the space. Web services have gained rapid popularity because of the pragmatic, simple and flexible ways they allow applications to link over the Internet. XML tuple spaces take the same benefits of pragmatism, simplicity and flexibility a few steps further. They enable applications to exchange XML documents asynchronously and with multiple parties, while leaving both the sending and receiving parties much flexibility in how they use these documents..."

  • [May 02, 2002] REST Architectural Style and TupleSpaces. In Alternative Web Services Architectures BOF," Sam Ruby writes: "The REST wiki suggests that the REST architectural style is most closely related to that of TupleSpaces. One important difference is that in TupleSpaces the sender does not identify the recipient. Data is addressed and routed based on content. Is there a place for such a model in 'Alternative Web Services Architectures'?..."

  • "How to use the Internet as a reliable means of information exchange." By Brian Hochgurtel (Rogue Wave Software, Boulder, CO, USA) From FrontRange December 17, 2001. "Using a tuple space in conjunction with XML brings together the concepts of loosely coupled and asynchronous. David Gelernter of Yale University first developed the idea of a tuple space with his Linda programming language in 1983. In Linda, a process could pass information to another process by inserting tuples into a tuple space. A tuple is just a list of values, whereas a tuple space contains these values in such a way they can be searched for with a template containing hints of the information an application may be trying to find. The information in the tuple space is asynchronous because the data may be there long after the application that placed it in the space has stopped executing. In Sun's JavaSpaces and IBM's Tspaces, an object, rather than a value, gets written to the space for use by other applications. Having this asynchronous object data available is important for applications that run for short periods of time. Instead of creating new information each time the application loads, it can just connect to the tuple space to receive the needed information. A tuple space like this can also provide a means for several applications to share the same object data. So far, the most common use of a tuple has been with objects, but since a tuple is really just a list of values it can take other forms -- including XML. Another advantage to using XML within a tuple space is the ability to use Web services to move information in and out of the space. A Web service is a combination of XML and standard protocols such as HTTP, FTP or SMTP, known as the Web protocol stack. The protocol takes care of routing the Web service and provides security while the XML contains the data. By using these protocols, a Web service already complies with the firewall policy -- meaning there isn't any new network configuration required. In addition, a tuple space may provide an additional layer of security within itself, which regulates who has access to particular documents. Using a certificate assigned to a user by an administrator, a document may be targeted towards a particular user such that the intended recipient is the only one able to receive the document. By regulating both access and actions, the sharing of XML data between disparate parties becomes highly regulated and allows documents to be securely exchanged. If a corporation decides to embrace XML and Web services as a communication mechanism, right now there really isn't a way to ensure this is a safe way to share data. Placing thousands of XML documents on a network drive in an ambiguous location is not the best option either. The best option would be to use XML in combination with a tuple space. This way, a developer can take advantage of the loosely coupled nature of XML and the ability to search for data using XQL, and use Web services as a means to communicate with remote locations. Combine this with the asynchronous nature of a tuple space and its ability to manage security, and suddenly a developer has much better options for creating applications that work over the Web."

  • "XML-Tuples and XML-Spaces." By David Moffat. Version 0.7. ATN ITD, UNC-CH, 25-March-1999. "This paper describes an implementation of tuples and tuple-spaces using XML. Tuple spaces were first described by David Gelernter long before the advent of XML [Nicholas Carriero and David Gelernter, 'Linda in Context', CACM 32/4 (1984), pages 444-458]. In general, a 'tuple' is simply a list of values, such as (12, 7, 48) or ('ra', 'gg', 'mo', 'pp') or ('Karl', 33, 125.7). A tuple-space is a public repository or buffer that can contain tuples. The tuple-space serves as an associative memory, in that tuples in the tuple-space can be accessed by matching some or all the elements of the tuples to values or types presented in a 'template', which is simply a tuple set up for this matching. Client programs can register to be notified of changes in a tuple-space. Current implementation of tuples -- 'JavaSpaces', by researchers at Sun Microsystems, and 'T Spaces' by researchers at IBM -- build upon the generic concept of tuples and tuple-spaces in various ways: the tuples are Java objects; there are more sophisticated ways to match and to access the tuples (IBM); the tuples can be stored in databases for persistence (IBM). The work in the present paper is inspired by the more sophisticated approach of the researchers at IBM. To anticipate this paper's summary, using XML for the tuples and for commands -- that is, using XML, not the objects of a particular language, as the 'native' representation -- brings tuple-spaces to new heights of generality and flexibility..."

  • "XML Dataspaces for Mobile Agent Coordination." By Giacomo Cabri, Letizia Leonardi, and Franco Zambonelli (Dipartimento di Scienze dell'Ingegneria, Università di Modena, Italy). In Proceedings of the 2000 ACM Symposium on Applied Computing [March 19 - 21, 2000, Como Italy] Volume 1, pages 181-188. [Author contacts: Phone: +39-059-376735; Fax: +39-059-376799; E-mail: {giacomo.cabri, letizia.leonardi, franco.zambonelli}] Abstract: "This paper presents XMARS, a programmable coordination architecture for Internet applications based on mobile agents. In XMARS, agents coordinate -- both with each other and with their current execution environment -- through programmable XML dataspaces, accessed by agents in a Linda-like fashion. This suits very well the characteristics of the Internet environment: on the one hand, it offers all the advantages of XML in terms of interoperability and standard representation of information; on the other hand, it enforces open and uncoupled interactions, as required by the dynamicity of the environment and by the mobility of the application components. In addition, coordination in XMARS is made more flexible and secure by the capability of programming the behaviour of the coordination media in reaction to the agents' accesses. An application example related to the management of on-line academic courses shows the suitability and the effectiveness of the XMARS architecture. [...] The presented XMARS architecture, by exploiting the power and the flexibility of a programmable Linda-like coordination model in the context of XML dataspaces, may provide several advantages in Internet applications based on mobile agents. In fact, while programmable Linda-like coordination suits the mobility of the application components and the openness of the Internet scenario, the emergent XML standard for Internet data representation may guarantee a high-degree of interoperability between heterogeneous components. However, apart from the need of updating portions of the current implementation (as discussed section 3), there are still several issues to be solved to make the XMARS architecture practically usable. These issues mainly relates to the lack of some XML specifications that are instead necessary for any effective management (and consequently for a tuple-based management) of XML documents. First of all, the XML schemas specification will permit to better specify data types in XML documents than the current version; this specification, together with the integration of XML namespaces in the current implementation, will be of great help in translating XML fields into Java objects (and viceversa), and in improving the effectiveness of the pattern matching mechanism. Second, the XML fragments specification will precisely define how fragments of an XML document can be extracted and inserted in a harmless way (i.e., preserving the validity of the XML document itself), thus meeting the need of handling single elements inside a possibly long document and, in the context of XMARS, enabling the system to extract/insert tuples representing a fragment of a large document in a consistent way. Strictly related, the XLink and XPointer specifications, which will rule the connections between different (parts of) XML documents, will possibly lead to richer and more complex tuple types." Similarly: "XML Dataspaces for the Coordination of Internet Agents" in Applied Artificial Intelligence Volume 15, Number 1 (January 2001), pages 35-58. The document is also available in Postscript format. See the related collection of technical papers from the MOON Project - Mobile Object Oriented Environments. [cache]

Hosted By
OASIS - Organization for the Advancement of Structured Information Standards

Sponsored By

IBM Corporation
ISIS Papyrus
Microsoft Corporation
Oracle Corporation


XML Daily Newslink
Receive daily news updates from Managing Editor, Robin Cover.

 Newsletter Subscription
 Newsletter Archives
Globe Image

Document URI:  —  Legal stuff
Robin Cover, Editor: