Persistence+undoability=transactions

Persistence means objects live potentially forever. Undoability means that any change to a program's store can potentially be undone. In their design and implementation of support for single-threaded nested transactions in Standard ML of New Jersey (SML/NJ), the authors provide persistence and undoability as orthogonal features and combine them in a simple and elegant manner. They provide support for persistence through an SML interface that lets users manipulate a set of persistent roots and provides a save function that causes all data reachable from the persistent roots to be moved into the persistent heap. They provide support for undoability through an SML interface that exports two functions: checkpoint, which checkpoints the current store, and restore, which undoes all changes made to the previously checkpointed store. Finally, they succinctly define a higher-order function transact completely in terms of the interfaces for persistence and undoability.<<ETX>>

[1]  Gregory F. Johnson,et al.  Stores and partial continuations as first-class objects in a language and its environment , 1988, POPL '88.

[2]  Robin Milner,et al.  Definition of standard ML , 1990 .

[3]  David Notkin,et al.  Gandalf: Software development environments , 1986, IEEE Transactions on Software Engineering.

[4]  David J. DeWitt,et al.  The EXODUS Extensible DBMS Project: An Overview , 1989 .

[5]  Abraham Silberschatz,et al.  A theory of relaxed atomicity (extended abstract) , 1991, PODC '91.

[6]  William E. Weihl,et al.  Local atomicity properties: modular concurrency control for abstract data types , 1989, TOPL.

[7]  Maurice Herlihy,et al.  Inheritance of synchronization and recovery properties in Avalon/C++ , 1988, Computer.

[8]  Lily B. Mummert,et al.  Camelot and Avalon: A Distributed Transaction Facility , 1991 .

[9]  Luca Cardelli. Amber Combinators and Functional Programming Languages , 1985, Lecture Notes in Computer Science.

[10]  Mahadev Satyanarayanan,et al.  Coda: A Highly Available File System for a Distributed Workstation Environment , 1990, IEEE Trans. Computers.

[11]  Henry Ledgard,et al.  Reference Manual for the ADA® Programming Language , 1983, Springer New York.

[12]  Peter Buneman,et al.  Types and persistence in database programming languages , 1987, CSUR.

[13]  Jeannette M. Wing,et al.  Concurrent atomic garbage collection , 1990 .

[14]  Ronald Morrison,et al.  An Approach to Persistent Programming , 1989, Comput. J..

[15]  Renzo Orsini,et al.  GALILEO: a strongly-typed, interactive conceptual language , 1985, TODS.

[16]  Joachim W. Schmidt,et al.  Some high level language constructs for data of type relation , 1977, TODS.

[17]  Alfred Z. Spector,et al.  Support for Distributed Transactions in the TABS Prototype , 1985, IEEE Transactions on Software Engineering.

[18]  Paul R. Wilson,et al.  Demonic memory for process histories , 1989, PLDI '89.

[19]  Andrew W. Appel,et al.  Debugging standard ML without reverse engineering , 1990, LISP and Functional Programming.

[20]  David C. J. Matthews A Persistent Storage System for Poly and ML , 1987 .

[21]  William J. Bolosky,et al.  Mach: A New Kernel Foundation for UNIX Development , 1986, USENIX Summer.

[22]  Jeannette M. Wing,et al.  Reliable distributed computing with Avalon/Common Lisp , 1990, Proceedings. 1990 International Conference on Computer Languages.

[23]  Ronald Morrison,et al.  Persistent Languages and Architectures , 1990, Security and Persistence.

[24]  J. Gregory Morrisett,et al.  Adding threads to Standard ML , 1990 .

[25]  Peter Lee,et al.  The ergo support system: an integrated set of tools for prototyping integrated environments , 1988, SDE 3.

[26]  Martín Abadi,et al.  Dynamic typing in a statically-typed language , 1989, POPL '89.

[27]  Andrew W. Appel,et al.  Simple generational garbage collection and fast allocation , 1989, Softw. Pract. Exp..

[28]  Robert Harper,et al.  Typing first-class continuations in ML , 1991, POPL '91.

[29]  Barbara Liskov,et al.  Guardians and Actions: Linguistic Support for Robust, Distributed Programs , 1983, TOPL.

[30]  Richard C. H. Connor,et al.  On the Integration of Object-Oriented and Process-Oriented Computation in Persistent Environments , 1988, OODBS.

[31]  Steven Sinofsky,et al.  Managing Persistent Data with Mneme: Designing a Reliable, Shared Object Interface , 1988, OODBS.

[32]  Luca Cardelli The Amber Machine , 1985, Combinators and Functional Programming Languages.

[33]  Nancy A. Lynch,et al.  Introduction to the Theory of Nested Transactions , 1986, Theor. Comput. Sci..

[34]  E. B. Moss,et al.  Nested Transactions: An Approach to Reliable Distributed Computing , 1985 .

[35]  John Mylopoulos,et al.  A language facility for designing database-intensive applications , 1980, TODS.