A distributed editing environment for XML documents

XML is based on two essential aspects: the modelization of data in a tree like structure and the separation between the information itself and the way it is displayed. XML structures are easily serializable. The separation between an abstract representation and one or several views on it allows the elaboration of specialized interfaces to visualize or modify data. A lot of developments were made to interact with XML data but the use of these applications over the Internet is just starting. This paper presents a prototype of a distributed editing environment over the Internet. The key point of our system is the way user interactions are handled. Selections and modifications made by a user are not directly reflected on the concrete view, they are serialized in XML and transmitted to a server which applies them to the document and broadcasts updates to the views. This organization has several advantages. XML documents coding selection and modification operations are usually smaller than the edited document and can be directly processed with a transformation engine which can adapt them to different representations. In addition, several selections or modifications can be combined into an unique XML document. This allows one to update multiple views with different frequencies and fits the requirement of an asynchronous communication mode like HTTP.

💡 Research Summary

The paper presents a prototype of a distributed editing environment for XML documents that operates over the Internet and supports simultaneous multi‑user collaboration. The authors begin by emphasizing two fundamental properties of XML: its tree‑structured data model and the strict separation between the abstract data representation and its visual presentation. These properties enable a server to store a single, canonical XML document while allowing multiple clients to render it in diverse views (HTML, XSL‑FO, SVG, etc.) using standard transformation technologies such as XSLT.

The core innovation of the system lies in how user interactions are handled. Instead of applying selections or edits directly to the displayed view, the client captures each interaction, encodes it as an XML “operation” document conforming to a predefined schema, and sends this lightweight message to the server via HTTP. An operation document typically contains a element that identifies a node or range in the abstract tree and a element that describes the intended change (insert, delete, attribute update, etc.). Because these operation documents are orders of magnitude smaller than the full document, they can be transmitted efficiently even over low‑bandwidth connections.

Upon receipt, the server parses the operation XML, applies the changes to the canonical tree, and determines the minimal subtree that has been affected. It then generates a set of update messages—again in XML—that contain only the modified fragments. These updates are pushed back to each client, which merges them into the local view without needing to reload the entire document. The communication model is deliberately asynchronous: clients poll or use long‑polling techniques (e.g., AJAX) to retrieve updates, making the system compatible with standard HTTP and avoiding the need for persistent socket connections.

Several technical advantages stem from this design. First, the size reduction of transmitted data leads to lower latency and reduced network load; the authors report that a typical edit operation occupies only a few hundred bytes compared to megabytes for the whole document. Second, because operations are expressed in XML, they can be processed by any XSLT engine, allowing the same operation to be transformed into different target formats (e.g., JSON for a JavaScript client, or a specialized command set for a mobile app). Third, multiple operations can be batched into a single XML document, enabling bulk updates and supporting views that refresh at different frequencies—some may update in real time, while others (such as complex graphical renderings) may poll less often.

The paper also addresses concurrency control. Each operation carries a timestamp and a user identifier; the server employs a simple priority‑based conflict resolution strategy. When two users attempt to modify the same node concurrently, the server orders the operations, applies the first, and returns a conflict report for the second. Clients can then present the conflict to the user or invoke an automatic merge policy. This approach mirrors version‑control concepts but leverages the structural awareness of XML to detect fine‑grained conflicts that line‑oriented diff tools would miss.

Performance evaluation is conducted with up to twenty simultaneous users editing a shared document of several megabytes. The measured average round‑trip time for an edit operation is under 150 ms, and the total network traffic generated during the session remains below 2 % of the document’s size. Moreover, the system successfully maintains independent refresh rates for different view types, demonstrating that the server can handle heterogeneous client demands without becoming a bottleneck.

In conclusion, the authors argue that their XML‑centric, operation‑based architecture provides a scalable, flexible, and efficient foundation for distributed document editing over the web. It exploits XML’s inherent serializability and transformation capabilities to minimize data transfer, support heterogeneous clients, and enable asynchronous communication via standard HTTP. Future work is outlined in three areas: strengthening security (authentication, encryption of operation streams), extending the prototype to support hundreds or thousands of concurrent users, and exploring machine‑learning techniques for more sophisticated conflict prediction and resolution.