Moving Between Contexts

Paper presented at DSV-IS'95 part of the Eurographics DSV-IS Series of Workshops on the Design Specification and Verification of Interactive Systems.

Download full paper in PDF (124K) or compressed postscript (672K)

Full reference:

A. J. Dix (1995). Moving between contexts. Design, Specification and Verification of Interactive Systems '95, Eds. P. Palanque and R. Bastide. Toulouse, France, Springer Wien. pp. 149-173.

Abstract

Any action is performed in a particular context. So what does it mean to do the 'same' thing in a different context? There is no simple answer to this question, it depends on the interpretation of the operation and even then may be ambiguous. This is not a purely theoretical problem, but occurs in practical computational problems. This paper examines this issue looking at three different problems: multi-user undo, distributed update and the simultaneous development of a document in multiple formats. In each case, we find formal rules which any sensible translation must obey. We also see that dynamic pointers, a generic specification and implementation concept defined in previous work, can be used to generate default translation rules which suffice in many circumstances. This is because dynamic pointers can themselves be seen as a translation of location information between different contexts.

Contents

1 Introduction

2 Group and long-term undo

2.1 The problem

2.2 Commutativity

2.3 Levels of interpretation

2.4 Changing contexts

2.5 Example translations

3 Merging updates

3.1 Moving between contexts

3.2 Long term interaction

3.3 They are all different

4 Composing translations

4.1 Undo composition

4.2 Merge composition

5 Dynamic pointers

5.1 Updates - the pull function

5.2 Using dynamic pointers for translations

5.3 More properties of dynamic pointers

6 Parallel development

6.1 Working together

6.2 Translators

6.3 A common format

6.4 Maintaining an invariant

6.5 Using dynamic pointers

6.6 Generating pull functions

7 Conclusions

Bibliography

Gregory D. Abowd and Alan J. Dix (1992).

Giving undo attention. Interacting with Computers, 4(3): pp. 317-342.

A. J. Dix (1995).

Dynamic pointers and threads. Collaborative Computing, 1(3): pp. 191Ð216.

A.J. Dix.

Formal Methods for Interactive Systems. Academic Press, 1991.

Alan J. Dix and Victoria C. Miles (1992).

Version control for asynchronous group work. Technical Report YCS 181, Computer Science Dept., University of York, U.K.. (Poster presentation HCI'92: People and Computers VII).

C.A. Ellis and S.J. Gibbs (1989).

Concurrency control in groupware systems. SIGMOD Record, 18(2): pp. 399-407. (Proceedings of 1989 ACM SIGMOD International Conference on Management of Data.)

M. D. Harrison and A. J. Dix (1990).

Modelling the relationship between state and display in interactive systems. In P.Gornay and M.J.Tauber, editors, Visualisation in Human--Computer Interaction, LNCS 439, pp. 241-249. Springer-Verlag.

J. J. Kistler and M. Satyanarayanan (1992).

Disconnected operation in the coda file system. ACM Transactions on Computer Systems, 10(1): pp. 3-25.

Atul Prakash and Michael J. Knister (1992).

Undoing actions in collaborative work. In CSCW'92 - Proceedings of the Conference on Computer-Supported Cooperative Work, pp. 273-280. ACM Press.

A. Schill (1995).

Cooperative Office Systems. Prentice Hall.

P. Wright, A. Monk, and M. Harrison (1992).

State, display and undo: a study of consistency in display based interaction. Technical report, University of York.