FP-DavidSun

From CS294-10 Visualization Fa07

1 Proposal
2 Initial Problem Presentation
3 Midpoint Design Discussion
4 Final Deliverables

[edit] Proposal

Visualizing Group Editing History

[edit] Group Members

David Sun

[edit] Description

Collaborative editors allow multiple users to edit the same digital artifact from geographically dispersed locations at the same time or at different times. The shared artifact can be any digital object ranging from papers documents, design drawings, music compositions, or even game states. Group undo is a key features that supports error correction and exploration of alternatives. The impact of an error is completely localized in a single user editing context, but in a multi-user environment, the effect can be multiplicatively exacerbated. Group undo allows the user to revert the document to some state with the errors eliminated. However, since multiple people can be contributing to the document, an error may or may not be detected in time before new and useful contributions are added to the document. At this point, undoing the erroneous action creates something of a time-traveling paradox in which the past has some complex effect on the present and how would the present change if the past is undone. Fortunately, there are existing algorithms that allow the past to be undone and that evaluates the present with reasonable semantics. The problem with applying these algorithms to actual applications is that they tend to be specified at the level of primitive editing operations such as insert and delete, which is commonly what's found in an editing history. However, this level of history representation makes it very difficult for the user to decide which actions needs to be undone in order to bring the document to the desired state. In this project I would like to design an effective history visualization metaphor that allows the user to easily specify their intention and clearly see the consequences of their actions before they are carried out. This not only helps the user in correcting mistakes but also exploring alternative design decisions.

[edit] Existing Work

There has been a large body of work in visualizing different version of the same text document. A commonly seen example is the diff operation in CVS repositories or Wiki pages. The diff algorithm works only at the textual level and does not account for change to text attributes, which is part of the standard document model in rich text editing. Other work has examined the "editing difference" between not only text but also graphics, and systems have been built that supports the dynamic composition of different versions [[1]]. In addition to the different underlying mechanisms used, the visualization proposed here is geared more towards online correction of errors than towards offline composition of version, though the technique would certainly be applicable towards the later task.