HTML is used for editing Wiki pages. In case of concurrent modifications, Wikis generally apply the last writer wins rule. Consequently, modifications done by some users may not appear in the last visible page. This is a kind of lost updates. Our requirements to improve the functionality of cooperative editors can be refined as: a good cooperative editor should allow anyone to write any shared data at any time without lost updates. The existing version control systems such as CVS (Berliner, 1990) avoid lost updates. However, CVS was originally designed to support cooperative software development. Only text files containing code sources such as C file and Java files are considered for merging. In this context, when conflicting changes are performed, conflicts appear inside merged files. A special syntax is used to clearly help programmers to locate the problem. Other shared data types are considered as binary files and concurrent changes on this type of data are not merged. Consequently, CVS allows anyone to write any text files at any time without lost updates. We want to build a cooperative editor that allows anyone to write any kind of data, not only text files, but also XML files, CAD files, calendar files at any time without lost updates. A generic synchronizer that enables to merge any data type without lost upinria-00139704,

Abstract. A collaborative object represents a data type (such as a text document or a filesystem) designed to be shared by multiple geographically separated users. Data replication is a technology to improve performance and availability of data in distributed systems. Indeed, each user has a local copy of the shared objects, upon which he may perform updates. Locally executed updates are then transmitted to the other users. This replication potentially leads, however, to divergent (i.e. different) copies. In this respect, Operational Transformation (OT) algorithms are applied for achieving convergence of all copies, i.e. all users view the same objects. Using these algorithms users can apply the same set of updates but possibly in different orders since the convergence should be ensured in all cases. However, achieving convergence with the OT approach is still a critical and challenging issue. In this paper, we address an open convergence problem when the shared data has a linear structure such as list, text, ordered XML tree, etc. We analyze the source of this problem and we propose a generic solution with its formal correctness. 1

infinite state systems

When distributed clients query or update shared data, eventual consistency can provide better availability than strong consistency models. However, programming and implementing such systems can be difficult unless we establish a reasonable consistency model, i.e. some minimal guarantees that programmers can understand and systems can provide effectively. To this end, we propose a novel consistency model based on eventually consistent transactions. Unlike serializable transactions, eventually consistent transactions are ordered by two order relations (visibility and arbitration) rather than a single order relation. To demonstrate that eventually consistent transactions can be effectively implemented, we establish a handful of simple operational rules for managing replicas, versions and updates, based on graphs called revision diagrams. We prove that these rules are sufficient to guarantee correct implementation of eventually consistent transactions. Finally, we present two operational models (single server and server pool) of systems that provide eventually consistent transactions. 1.

apport de rechercheinria-00071213, version 1- 23 May 2006Proving correctness of transformation functions in collaborative editing systems

We introduce a new tool employing the sketching synthesis technique in programs annotated with declarative contracts. While Sketch, the original sketching tool, reasons entirely on imperative code, Sketch # works on top of the full-fledged specification language Spec#. In such a language, highlevel specifications in the form of pre- and postconditions annotate code, which can be formally verified using decision procedures. But once a given method’s implementation is verified, there is no need to look inside its body again. An invocation of the method elsewhere simply implies its specified postcondition. The approach widens the scalability of the sketching technique, as reasoning can be done in a modular manner when specifications accompany implementations. This paper describes our implementation of Sketch # on top of Spec # and its program verifier Boogie. We also recount our experience applying the tool to aid optimistic parallel execution frameworks, where we used it to discover and verify operation inverses, commutativity conditions, and operational transformations for several data structures.

Abstract — Coordination between different organizations in dynamic situations, such as a disaster response, is challenging. Organizations are autonomous and coordinate the situation from their point of view. There is no central authority to coordinate all operations. To coordinate their actions, organizations need to exchange information on what they are doing. However, they cannot share everything with everybody due to privacy, regulatory or strategic reasons. Currently, only e-mail, telephone or fax are used to exchange information. This makes detecting and handling of conflicting views on the situation very difficult. We propose an approach for inter-organizational process management for these kinds of dynamic scenarios. It allows different organizations to share selected activities by replicating them in the different workspaces of the organizations. State changes of shared activities are propagated optimistically. We explain detecting and handling of two different types of conflicts that can occur in this setting. We provide an implementation and interviews to validate the concepts. I.

Abstract. Collaborative editing consists in editing a common document shared by several independent sites. Conflicts occurs when different users perform simultaneous uncompatible operations. Centralized systems solve this problem by using locks that prevent some modifications to occur and leave the resolution of conflicts to users. Optimistic peer to peer (P2P) editing doesn’t allow locks and uses a Integration Transformation IT that reconciliates conflicting operations and ensures convergence (all copies are identical on each site). Two properties TP1 and TP2, relating the set of allowed operations Op and the transformation IT, have been shown to ensure convergence. The choice of the set Op is crucial to define an integration operation that satisfies TP1 and TP2. Many existing algorithms don’t satisfy these properties and are incorrect. No algorithm enjoying both properties is known for strings and little work has been done for XML trees in a pure P2P framework. We focus on editing XML-like trees, i.e. unranked-unordered labeled trees also considered in the Harmony project. We show that no transformation satisfying TP1 and TP2 exists for a first set of operations but that TP1 and TP2 hold for a richer set of operations, provided that some decoration is added to the tree. We show how to combine our approach with any convergent editing process on strings to get a convergent process. We have implemented our transformation using a P2P algorithm inspired by Ressel et al. whose correctness relies on underlying partial order structure generated by the dependence relation on operations.