Figure 1
Integration of two concurrent operations
Source publication
Reconciliating divergent data is an important issue in concurrent engineering, mobile computing and software configuration management. Currently, a lot of synchronizers or merge tools perform reconciliations. However, they do not define what is the correctness of their synchronisation. In this paper, we propose to use a transformational approach as...
Similar publications
Reconciliating divergent data is an important issue in concurrent engineering mobile computing and software configuration management. Currently, a lot of synchronizers or merge tools perform reconciliations. However, they do not define what is the correctness of their synchronisation. In this paper, we propose to use a transformational approach as...
Citations
... In asynchronous collaboration mode, e.g Distributed Version Control System (DVCS) softwares, users modify their document in isolation and synchronize after to establish a common view of the document. Usually, these kind of systems manages the modifications as a set of state (state-based approach) as on git system [46] or So6 [26]. When a replica receives a remote state, it computes the difference between the local state of the document and the received one before merging the modifications. ...
... ). [10, 26, 35] algorithms are operation-based are designed for collaborative editing context. They have been proposed to maintain the consistency of the shared document. ...
... It is more appropriate to inform the users and let him check the result. For example, So6 [26] that is similar to git merge upon on OT algorithm, cannot merge silently the modifications when two concurrent operations are generated. the result is returned to the user and let him to solve the conflicts. ...
Merging mechanism is an essential operation for version control systems. When each member of collaborative development works on an individual copy of the project, software merging allows to reconcile modifications made concurrently as well as managing software change through branching. The collaborative system is in charge to propose a merge result that includes user’s modifications. Theusers now have to check and adapt this result. The adaptation should be as effort-less as possible, otherwise, the users may get frustrated and will quit the collaboration. This paper aims to reduce the conflicts during the collaboration and im prove the productivity. It has three objectives: study the users’ behavior during the collaboration, evaluate the quality of textual merging results produced by specific algorithms and propose a solution to improve the r esult quality produced by the default merge tool of distributed version control systems. Through a study of eight open-source repositories totaling more than 3 million lines of code, we observe the behavior of the concurrent modifications during t he merge p rocedure. We i dentified when th e ex isting merge techniques under-perform, and we propose solutions to improve the quality of the merge. We finally compare with the traditional merge tool through a large corpus of collaborative editing.
... This solution involves an operation-based system that stores the history of document changes for efficient conflict resolution. For the merging process, the operational-transformation approach [17] is used to maintain the position of the nodes during the merge. We exploit the idea of operational-transformation in our proposed XML Schema merging model by defining functions that adjust positions of the affected schema nodes. ...
... The transformation approach adopted in our merging technique is widely known in the domain of data synchronization [17]. In the synchronization process, two divergent copies of the file are made identical by integrating them. ...
XML Schema standards often undergo several revisions to fit application requirements and business demands. In order to be successful, the development process of such standards must be collaborative allowing multiple users to work on the same schema. In this editing environment, the ability to merge branched versions of the schema is significant in certain situations. Using conventional three-way XML merging tools is not suitable for the purpose of merging XML Schema because the tree model of XML Schema is different from that of XML document.
This paper deals with an essential activity enabling automatic XML Schema merging and conflict resolution based on the model of XML Schemas. We present rules for XSD merging and conflict handling, and describe how this can be achieved by combining three-way and operational-transformation approaches. Developing a prototype of our approach, we test it against a set of XSDs. Experimental results (compared to other three-way merge tools, including, 3DM and DeltaXML) show that our approach produces merged versions of high quality and reports more meaningful conflicts with respect to schema changes.
... The distributed textual merge algorithms that we evaluate are: the default git merge, one operational transformation approach, and two commutative replicated data types. All these approaches were originally proposed or adapted to manage asynchronous collaborative editing such as synchronizer or wikis[20,33]. They all consider the text as a sequence of lines. ...
... However, all other studied merge tools evaluated can integrate an awareness mechanism without modify their results as in[27]. For instance, the so6 tool[20], used in the web software forge Libresource, adds conflict markers on top of a traditional operational transformation merge mechanism. Another threat is the metric used in this paper. ...
Software merging is a time-consuming and error-prone activity but essential to large-scale software development. Developers use software merging tools, but if such tools return results with too many conflicts and errors, this activity becomes even more difficult. To help developers, several algorithms have been proposed to improve the automation of merge tools. These algorithms aim at minimising conflict situations and therefore improving the productivity of the development team, however no general framework is proposed to evaluated and compare their result.
This paper proposes a methodology to measure the effort required to use the result of a given merge tool. We employ the large number of publicly available open-source development histories to automatically compute this measure and evaluate the quality of the merging tools results. We use the simple idea that these histories contains both the concurrent modifications and their merge results as approved by the developers. Through a study of six open-source repositories totalling more than 2.5 millions lines of code, we show meaningful comparison results between merge algorithms and how to use the results to improve them.
... In asynchronous collaborative applications, users modify shared documents independently without immediately observing changes being performed by other users. These applications usually use some kind of floor control [3] that allow a single user to modify each document (or document area), or allow concurrent updates to occur and combines them using either a three-way-merge tool [4] or patch-based techniques [5], [6]. In synchronous collaborative applications, each user immediately observes the changes performed by the other users. ...
... Additionally, most OT solution support only insert and delete operations. Molli et al. propose a multi-synchronous [24] and an asynchronous [5] collaborative framework. Theses approaches provide awareness mechanisms such as state treemaps [25] or conflict blocks similar to version control systems. ...
Collaborative editing tools have become increasingly popular in the last decade, with some systems being used by massive numbers of users. While traditionally collaborative editing systems would either target synchronous or asynchronous collaboration settings, some recent systems support both types of collaboration, even supporting disconnected work.
In this paper we analyze the limitations of existing systems and propose a data management solution that overcomes such limitations. The proposed concurrency control algorithm, based on conflict-free data types, builds on the ideas previously developed
for synchronous collaboration, extending them to support asynchronous collaboration.
Our solution also includes the necessary information for providing comprehensive awareness information to users. The evaluation of our algorithm shows that comparing our solution with traditional solutions in collaborative editing, the conflict resolution
strategy proposed in this paper leads to results closer to the ones expected by users.
... In asynchronous collaboration mode, e.g Distributed Version Control System (DVCS) softwares, users modify their document in isolation and synchronize after to establish a common view of the document. Usually, these kind of systems manages the modifications as a set of state (aka state-based approach) as on git system [39] or So6 [23]. When a replica receives a remote state, it computes the difference between the local state of the document and the received one before merging the modifications. ...
... Operational Transformation (OT) [9], [32], [23] algorithms are operation-based designed for collaborative editing context. They have been proposed to maintain the consistency of the shared document. ...
... It is more appropriate to inform the users and let him check the result. For example, so6 [23] that is similar to diff3 upon on OT algorithm, cannot merge silently the modifications when two concurrent operations are generated. the result is returned to the user and let him to solve the conflicts. ...
In asynchronous collaborative systems, merging is an essential component. It allows to reconcile modifications made concurrently as well as managing software change through branching. The collaborative system is in charge to propose a merge result that includes user's modifications. The users now have to check and adapt this result. The adaptation should be as effort-less as possible, otherwise, the users may get frustrated and will quit the collaboration. The objective of this paper is to improve the result quality of the textual merge tool that constitutes the default merge tool of distributed version control systems. The basic idea is to study the behavior of the concurrent modifications during merge procedure. We identified when the existing merge techniques under-perform, and we propose solutions to improve the quality of the merge. We finally compare with the traditional merge tool through a large corpus of collaborative editing.
... In this paper, we propose a new infrastructure for P2P timestamping and reconciliation, that may be useful for different types of P2P collaborative applications, however to be able to express the functionalities of our infrastructure, we focus on P2P collaborative text editing applications. Operational transformation (OT) [14] is one of the main distributed frameworks used for handling optimistic replication in the context of distributed text editing applications. The two most important aspects of OTs is that they are generic, i.e. they can handle different types of data (text, multimedia, etc), and it uses a set of generic operation transforms for reconciliation. ...
... However, to ensure eventual consistency during reconciliation, all involved operations must be stamped in continuous total order (timestamps values are integer ascending order). One well known OT solution [14] uses a centralized timestamp server to stamp operations (update, insert…) which limits scalability and may block in case of failures, or introduce bottlenecks. Besides, the size of the log used by OT at the timestamp server tends to be hudge and may be unmanageable in a single node. ...
... A patch is the unit of reconciliation that corresponds to a sequence of update operations (insert, update, delete) generated when saving a document in a text editor. Once these patches are stamped in a continuous timestamp order, they are used for reconciliation by the integration algorithm of OT solution based on the transformation functions proposed by [14] for text reconciliation. ...
We address the problem of optimistic replication for collaborative text editing in Peer-to-Peer (P2P) systems. This problem is challenging because of concurrent updating at multiple peers and dynamic behavior of peers. Operational transformation (OT) is a typical approach used for handling optimistic replication in the context of distributed text editing. However, most of OT solutions are neither scalable nor suited for P2P networks due to the dynamic behavior of peers. In this paper, we propose a scalable P2P reconciliation infrastructure for OT that assures eventual consistency and liveness despite dynamicity and failures. We propose a P2P logging and timestamping service called P2P-LTR (P2P Logging and Timestamping for Reconciliation) which exploits a distributed hash table (DHT) for reconciliation. While updating replica copies at collaborating peer editors, updates are stored in a highly available P2P log. To enforce eventual consistency, these updates must be retrieved in a specific total order to be reconciled at the peer editors. P2P-LTR provides an efficient mechanism for determining the total order of updates. It also deals with the case of peers that may join and leave the system during the update operation. We evaluated the performance of P2P-LTR through simulation; the results show the efficiency and the scalability of our solution.
... OT is recognized as a suitable approach to maintain consistency of shared documents. This approach is applied to develop both real-time and asynchronous collaborative editors [12, 13]. It consists of two main components: a generic integration algorithm which manages concurrent operations and transformation functions specific to a data model. ...
Existing Peer to Peer (P2P) collaborative editing systems do not al low any user to undo any modification. However, in such systems, users are not aware of others' modifications, hence, they could obtain duplicate work, conflicting modifications or malicious contents. In this paper, we propose a new undo framework called “UNO: Undo as a New Operation” in the Operational Trans- formation approach which does not limit the scalability of P2P algorithms. As a proof of concept, we apply our framework to build a P2P collaborative editor with undo capabilities in which any user can undo any modification.
... Next, the Masterkey replicates the patch in the P2P-Log (at the Log-Peers) by invoking sendToPublish(key, last-ts, patch) and acknowledges u 1 , with a message containing the validated timestamp value. If the Master-key local timestamp value (last-ts) is greater than ts, that means that there are previous validated patches available in the P2P-Log, generated by other users, that must be integrated in u 1 's document d before (e.g. for instance by using So6 [9] reconciliation engine which is based on operational transformation [7]). To accomplish this, u 1 must perform the retrieval procedure to get all missing patches in continuous timestamp order, by using get(h i (key+ts)), where h i is one of the replication hash functions. ...
In this paper, we address data reconciliation in peer-to-peer (P2P) collaborative applications. We propose P2P-LTR (Logging and Timestamping for Reconciliation) which provides P2P logging and timestamping services for P2P reconciliation over a distributed hash table (DHT). While updating at collaborating peers, updates are timestamped and stored in a highly available P2P log. During reconciliation, these updates are retrieved in total order to enforce eventual consistency. In this paper, we first give an overview of P2P-LTR with its model and its main procedures. We then present our prototype used to validate P2P-LTR. To demonstrate P2P-LTR, we propose several scenarios that test our solutions and measure performance. In particular, we demonstrate how P2P-LTR handles the dynamic behavior of peers with respect to the DHT.
... Another interesting approach for merging is a family of algorithms based on Operational Transformation (OT) [10]. There exists a abundant contribution to this topic, for both real-time merge in group editors [11] or asynchronous merge in data synchronizers [12]. The strong point of these approaches is their genericity: they can handle different data types in the same framework. ...
This paper presents the XWiki Concerto system, the P2P version of the XWiki server. This system is based on replicating wiki pages on a network of wiki servers. The approach, based on the Woot algorithm, has been designed to be scalable, to support the dynamic aspect of P2P networks and network partitions. These characteristics make our system capable of supporting disconnected edition and sub-groups, making it very flexible and usable.
... Next, the Master-key replicates the patch in the P2P-Log (at the Log-Peers) by invoking sendToPublish(key, last-ts, patch) and acknowledges u 1 , with a message containing the validated timestamp value. If the Master-key local timestamp value (last-ts) is greater than ts, that means that there are previous validated patches available in the P2P-Log, generated by other users, that must be integrated in u 1 's document d before (e.g. for instance by using So6 [10] reconciliation engine which is based on operational transformation [5]). To accomplish this, u 1 must perform the retrieval procedure to get all missing patches in continuous timestamp order, by using get(h i (key+ts)), where h i is one of the replication hash functions. ...
In this paper, we address data reconciliation in peer-to-peer (P2P) collaborative applications. We propose P2P-LTR (Logging and Timestamping for Reconciliation) which provides P2P logging and timestamping services for P2P reconciliation over a distributed hash table (DHT). While updating at collaborating peers, updates are timestamped and stored in a highly available P2P log. During reconciliation, these updates are retrieved in total order to enforce eventual consistency. In this paper, we first give an overview of P2P-LTR with its model and its main procedures. We then present our prototype used to validate P2P-LTR. To demonstrate P2P-LTR, we propose several scenarios that test our solutions and measure performance. In particular, we demonstrate how P2P-LTR handles the dynamic behavior of peers with respect to the DHT.
