The Forum uses existing Internet technology and infrastructure to create a globally accessible, highly secure, robust, scalable and persistent shared memory containing XML documents.

Forums are found using DNS. This provides a level of indirection insulating the caller from the exact location of the space. A DNS name could be something like "exchange.spacelysprockets.com" or "mobilespace.myorganization.com"

The interface to the Forum is SOAP over HTTP. These widely understood and deployed protocols permit support from a great variety of programming languages and platforms.

The Forum could be deployed on the Internet, an extranet, or an intranet. A natural place to deploy a Forum is in the "demilitarization zone" or DMZ of an organization, between two firewalls. In this configuration the Forum provides a document exchange gateway between the organization and the outside world.

XML (eXtensible Markup Language) is the ideal encoding mechanism for sharing information and functionality between disparate systems. The syntax can be easily read, understood and shared by developers, and a growing number of editing and translation tools make XML easy to use. Because XML is essentially text, many existing software technologies handle it with ease. Businesses can exchange XML-encoded data internally and externally over the Internet to remote enterprise systems and even to wireless devices, as long as they've established compatible XML vocabularies.

Tuple spaces were created at Yale University in the mid-1980's as part of the Linda coordination language, where they were used to coordinate interactions within parallel applications. More recent implementations of tuple-spaces include Sun's JavaSpaces and IBM's Tspaces--both Java-centric tuple space implementations.

A tuple space is a shared dataspace through which independently active processes communicate. This space can be thought of as a shared message store between cooperating processes. Messages (tuples) are written to the space by the sender and discovered by receivers using an associative lookup.

Tuple spaces provide for loosely coupled communication, decoupling senders and receivers in space and time. Decoupled in space, since senders and receivers can exist anywhere in the distributed system and do not have to know each other's location. Decoupled in time, since a receiver does not have to exist when the message is sent; messages are stored until the recipients are ready to receive them.

In contrast, tightly coupled communications rely on a rendezvous between a sender and a receiver. The sender must know the receiver's address and both the sender and the receiver must be available and ready to communicate simultaneously. Thus, where traditional systems require synchronous point-to-point links, tuple spaces offer asynchronous anonymity.

Tuple spaces provide a sort of multicast medium in through which multiple receivers can read a tuple written by a single sender. Point-to-point communications, on the other hand, require the sender to initiate a connection with each recipient. This multicast-like quality of tuple spaces allows for ad hoc and scalable collaboration where new participants can join a collaboration without the sender having to "discover" or connect to the participant.

The interface to tuple spaces is very simple. It only requires a handful of operations to write, read, and remove take tuples. Applications communicate with each other through the space, so senders and receivers don't need to know the protocols or the interfaces of each other, only that of the space.

Some tuple space implementations, including Ruple, provide a way for tuples to expire, to be deleted once their designated lifetime is gone. These tuples have a "shelf life", determined by a lease associated with the space entry.

The Forum is an XML Tuple Space implementation. The space stores XML documents. XML documents are written to the space and found by readers using and XML query syntax (XQL). The space supports any well formed XML document or fragment.

The Forum is a document-centric tuple space implementation. This is an important distinction.

Ruple uses a document-centered approach to tuple spaces. 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 heterogenous environments as it requires an object model and, in all practicality, ties you to a particular programming language and binary protocol. In contrast, Ruple's document-centric implementation of tuple spaces is independent of any particular programming language. It gives you the choice of processing the document (or not) with the tools at your disposal-depending on your language, environment, or preference.

The Forum supports any well formed XML document or document fragment. Well formed XML must be syntactically correct according to the XML 1.0 specification. 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.

Documents are discovered in the XML tuple space using an XML query syntax. The query is specified on a read or take operation. The Forum supports a subset of the XQL query language for XML documents. XQL provides a notation for addressing and filtering the elements and text of XML documents. As used with the Forum, a query specifies criteria for selecting an XML document as the target of a read(), readMultiple() or take() operation. In other words, if the elements in a document satisfy all the criteria in a query, we consider that the document satisfies the query. The document or documents (in the case of readMultiple) satisfying the query will be returned to the caller.

Sample queries:

/bookstore/book/title$eq$"Seven Years in Trenton"

//author/first-name$eq$"Toni"

//excerpt/p[. contains "dark" $and$ . contains " stormy"]

Documents written to the Forum have a "shelf-life". A lease specified when the document is written determines how long the document will be available in the space. If the document is still in the space when the lease expires then the document is removed by the Forum Reaper. By storing documents temporarily, the space allows for asynchronous and 1-to-many interactions.

Ruple uses X.509 digital certificates to identify the recipient of a document. When a document is written into the space, the writer may allow all readers or they may prescribe a limited set of users based on their digital certificate identity. If a user does not have permission to read a document, they would never see. It would be as if it did not exist.

In addition, the digital certificate serves as a mechanism for targeting the document towards the recipient based on their identity, rather than a network address--further decoupling sender and receiver.

XML documents are great for describing textual information; however, complications arise when content needs to be attached, such as a picture or an Excel spreadsheet. Ruple uses MIME attachments to accomplish such tasks. An attachment is content that can be associated and stored with a Forum entry or document. The content might consist of a file, a persisted object, another XML document or perhaps an image. This content is represented by an attachment, which can be retrieved, along with the XML document, from the Forum by a read, readMultiple, or take operation. When the host XML document is taken or deleted, all of its attachments also are taken or deleted.

 import com.roguewave.forum.*;

/**
 * Write an xml document to the forum
 */
public class W
{
    public static void main(String[] args) throws Exception {

        // Connect to the forum:
        String m_url = "http://forum.roguewave.com/forum/servlet/ForumServlet";
        Forum f = ForumFactory.createForum(m_url);

        // Set security policy:
        Authorizations auths = new AuthorizationsImpl();
        auths.allowAllReaders(true);

        // Write a document to the forum:
        String xmlDoc = "<color>purple</color>";
        int myLease = 604800; // 1 week
        int lease = f.write(xmlDoc, myLease, auths);
    }
}
	

import com.roguewave.forum.*;

/**
 * Read an xml document from the forum
 */
public class R
{
    public static void main(String[] args) throws Exception {

        // Connect to the forum:
        String m_url = "http://forum.roguewave.com/forum/servlet/ForumServlet";
        Forum f = ForumFactory.createForum(m_url);

        // Query for doc. containing "purple" as value of <color> tag:
        String query = "/color$eq$\"purple\"";  
        Entry entry = f.read(query, 0);

        // Print document, if successfully retrieved:
        if (entry != null) {
            String doc = entry.getDocument();
            System.out.println(doc);
        }
        else {
            System.out.println("Document not found");
        }
    }
}

A reverse auction is a typical B2B example that benefits from a many-to-many, loosely coupled communication paradigm. A business looking for a product or service writes an RFQ (Request for Quotes) into the space.The RFQ is targeted toward all takers, or perhaps to a constrained list of vendors. Vendors meanwhile wait for RFQs to come into the space and, when a suitable RFQ arrives, they write a Quote into the space, targeting the buyer. The buyer takes the quotes from the space and then responds to a particular vendor with a purchase order.

Document-centric tuple spaces, with their ability to temporally decouple a sender from a receiver, are ideal for implementing applications that involve intermittently connected devices such as PDAs, cell phones, and Communicators. In this example, we see a PDA, located perhaps in a warehouse, writing inventory data to a space from which it can be retrieved by a back office inventory application.

Remote telemetry applications using the document space model allows a control application to "broadcast" calibration information to a class of devices in the field and to reap instrument readings from those devices as they are periodically uploaded from the field stations.

The Forum can be used within an organization as a routing mechanism for XML documents coming into the organization, as a document way station for portal applications, or as an internal routing mechanism.

.

The secure aspects of the space can be used to securely distribute sensitive information. Ruple uses X.509 digital security certificates and HTTPS to ensure secure access and authentication.

Ruple can be used as the basis for business process automation and workflow applications coordinating the creation and exchange of documents between cooperating parties. Collaborative activities may be constrained to a single organization or they may span divisions and separate companies. within a company as well as workflows that span divisions and separate companies.

The Ruple Space can be used as a transformation buffer. Incoming documents are identified and transformed by transformer who writes the transformed document back into the space, or into another space, to be found by the intended application.

Ruple may be used as the basis of a web services intermediary to provide security and ease of deployment of web service applications.