We describe a model and notation for specifying and enforcing aspects of integrity policies, particularly separation of duties. The key idea is to associate a transaction control expression with each information object. This expression constrains the transactions which can be applied to that object to occur in the specified pattern. As operations are actually executed the transaction control expression gets converted to a history. This history serves to enforce separation of duties. We distinguish transient objects with a short lifetime from persistent objects which are long lived. Separation of duties is achieved by maintaining a complete history for transient objects but only a partial history for persistent objects. This is possible because of the system enforced rule that transactions are executed on persistent objects only as a side effect of execution on transient objects.

this paper, we propose a general framework for implementing undo in collaborative systems. The framework allows users to individually reverse their own changes, taking into account the possibility of conflicts between different users' operations that may prevent an undo. The proposed framework has been incorporated into DistEdit, a toolkit for building group text-editors. Based on our experience with DistEdit's undo facilities, we discuss several issues that need to be taken into account in using the framework, in order to ensure that a reasonable undo behavior is provided to users. We show that the framework is also applicable to single-user systems, since the operations to undo can be selected not just on the basis of who performed them, but by any appropriate criterion, such as the document region in which the operations occurred or the time interval in which the operations were carried out. Categories and Subject Descriptors: D.2.2 [Software Engineering]: Tools and Techniques -- User Interfaces; H.1.2 [Models and Principles]: User/Machine Systems -- Human Factors; H.2.2 [Database

The notions of serializability, linearizability and sequential consistency are used in the specification of concurrent systems. We show that the model checking problem for each of these properties can be cast in terms of the containment of one regular language in another regular language shuffled using a semi-commutative alphabet. The three model checking problems are shown to be, respectively, in Pspace, in Expspace, and undecidable. 1 Introduction A common way of specifying concurrent systems is to describe the desired sequential behavior of the system, and then to allow the implementation to execute certain operations in parallel, provided the appearance of sequential behavior is maintained for a suitable observer. The earliest such notion of correctness was serializability (see, for instance, [EGLT76, Pap86, BHG87]), which requires that a collection of transactions that are scheduled in parallel must produce the same result as the same transactions scheduled in some sequential ord...

The replacement of parts of software systems is an important aspect of programming methodology. Most of the research in this area has centered around support for modular construction and the clear separation of interface from implementation. The emphasis has been on producing easily modified static program structures.

Abstract—Ideas that are used in the design, development, and performance of concurrency control mechanisms have been summarized. The locking, time-stamp, optimistic-based mechanisms are included. The ideas of validation in optimistic approach are presented in some detail. The degree of concurrency and classes of serializability for various algorithms have been presented. Questions that relate arrival rate of transactions with degree of concurrency and performance have been briefly presented. Finally, several useful ideas for increasing concurrency have been summarized. They include flexible transactions, adaptability, prewrites, multidimensional timestamps, and relaxation of two-phase locking.

Th~s report has been subm~tted for ~ubllcatlon outs~de of IBM and w~ll probably be copyrighted ~f accepted for publ~cat~on It has ken Issued as a Research Report for early dlssem~nat~on of ~ts contents. In vlew of the transfer of copyr~ght to the outs~de publ~sher. ~ts d~str~butlon outs~de of IBM prlor to ~ubllcatlon should be l~m~ted to peer communlcatlons and spec~f~c requests After outs~de publ~catlon, requests should be f~lled only by reprlnts or legally obtamed coples of the art~cle (e g. payment of royalt~es) Research Division tB

The ability to undo operations is a standard feature in most single-user interactive applications. However, most current collaborative applications that allow several users to work simultaneously on a shared document lack undo capabilities; those which provide undo generally provide only a global undo, in which the last change made by anyone to a document is undone, rather than allowing users to individually reverse their own changes. In this paper, we propose a general framework for undoing actions in collaborative systems. The framework takes into account the possibility of conflicts between different users' actions that may prevent a normal undo. The framework also allows selection of actions to undo based on who performed them, where they occurred, or any other appropriate criterion. The proposed framework have been incorporated in DistEdit, a toolkit for building text group editors. Based on our experience, we discuss methods for maintaining the undo information in a groupware env...

We propose a formal model of concurrency control in object bases. An object base is like a database except that information is represented in terms of "objects" that encapsulate both data and the procedures through which the data can be manipulated. The model generalises the classical model of database concurrency control: it allows for nested transactions (as opposed to flat transactions) which may issue arbitrary operations (as opposed to just read and write operations). We establish an analogue to the classical serialisability theorem and use it to derive simple proofs of correctness of two concurrency control algorithms for object bases, namely Nested Two-Phase Locking (Moss' algorithm) and Nested Timestamp Ordering (Reed's algorithm). Concurrency control in object bases can be viewed as a combination of intra-object and inter-object synchronisation. The former ensures that each object's own methods are executed in serialisable fashion; the latter ensures the compatibility of trans...

The replacement of parts of software systems is an important aspect of programming methodology. Most of the research in this area has centered around support for modular construction and the clear separation of interface from implementation. The emphasis has been on producing easily modified static program structures.

This report has been submitted for publication outside of IBM and will probably be cooyrighted if accepted for publication. It has been issued as a Research Report for early dissemination of its contents. In view of the transfer of copyright to the outside publisher, its d~stribution outside of IBM prior to publication should be limited to peer commun~cations and specific requests. After outside publication, requests should be filled only by reprints or legally obtained copies of the art~cle (e.g., payment of royalties).