A sophisticated shell environment

An undo facility is an essential component of most interactive applications. In current operating system shells, whether textual or graphical, such facilities are typically very poor. Algorithms are presented for adding a recovery mechanism to a shell which allows previous commands to be selectively undone and redone, and previous versions of les to be recovered. The recovery mechanism involves making the shell control resources in a more intelligent way. Programs are run under greater control, with the shell monitoring and analysing their resource requests. This provides better high level information to the shell and, for example, provides techniques to prevent foreign or untrustworthy programs from doing any damage, and to reduce problems with con icting resource requests from concurrent programs. A prototype implementation called brush has been constructed to investigate the convenience and natural feel of these facilities. It is commandindependent and provided entirely at the user level. The idea is based on the interception of a particular class of system calls, using tracing facilities supported by many Unix operating systems. Recovery information required to implement selective undo is then stored according to the behaviour of the intercepted system calls. This doesn't involve any modi cation either to the kernel or to existing programs. The recovery mechanism maintains three components in the le system for purposes of selective undo and redo: a history le which consists of user-typed commands, a record le which keeps all le I/O requests made by system calls, and a personal directory in which old versions of les are located. These components enable the system to be brought back to any desired state. Users can reach all past copies of a le, without resorting to system administrator assistance. The system state is kept consistent during recovery, employing a con ictdetection mechanism that checks for the applicability of selective undo/redo. A shell environment with recovery facilities enables programs' interactions with the le system to be monitored very closely. Using this close monitoring, some Unix programs can be equipped with more sophisticated features. In this way, a make-like utility has been designed and implemented which provides automatic facilities in performing compilations of programs.

[1]  Atul Prakash,et al.  A framework for undoing actions in collaborative systems , 1994, TCHI.

[2]  Ian Holyer,et al.  A Recovery Mechanism for Shells , 2000, Comput. J..

[3]  Atul Prakash,et al.  Undoing actions in collaborative work , 1992, CSCW '92.

[4]  Rebecca Thomas A user guide to the UNIX system , 1982 .

[5]  Chunbo Zhou,et al.  Object-based nonlinear undo model , 1997, Proceedings Twenty-First Annual International Computer Software and Applications Conference (COMPSAC'97).

[6]  Michael B. Jones,et al.  Interposition agents: transparently interposing user code at the system interface , 1994, SOSP '93.

[7]  C. Marlin Brown,et al.  Human-Computer Interface Design Guidelines , 1998 .

[8]  Vasant Honavar,et al.  Intelligent agents for intrusion detection , 1998, 1998 IEEE Information Technology Conference, Information Environment for the Future (Cat. No.98EX228).

[9]  Edwina L. Rissland Ingredients of Intelligent User Interfaces , 1984, Int. J. Man Mach. Stud..

[10]  Andy Oram,et al.  Programming with GNU software , 1996 .

[11]  Stephen R. Bourne The Unix System , 1982 .

[12]  Erik H. Baalbergen Design and Implementation of Parallel Make , 1988, Comput. Syst..

[13]  Yiya Yang,et al.  User-oriented design of undo support , 1989 .

[14]  Thomas Berlage,et al.  A selective undo mechanism for graphical user interfaces based on command objects , 1994, TCHI.

[15]  Clayton H. Lewis,et al.  Concepts and implications of undo for interactive recovery , 1985, ACM '85.

[16]  Joost Verhofstad,et al.  Recovery Techniques for Database Systems , 1978, CSUR.

[17]  Jeffrey Scott Vitter US&R: A new framework for redoing (Extended Abstract) , 1984 .

[18]  Yiya Yang Undo Support Models , 1988, Int. J. Man Mach. Stud..

[19]  Sandra H. Rouse,et al.  Analysis and classification of human error , 1983, IEEE Transactions on Systems, Man, and Cybernetics.

[20]  Marko I. Vuskovic R-shell: a UNIX-based development environment for robotics , 1988, Proceedings. 1988 IEEE International Conference on Robotics and Automation.

[21]  Prasun Dewan,et al.  An editing-based characterization of the design space of collaborative applications , 1994 .

[22]  Chris J. Scheiman,et al.  UFO: a personal global file system based on user-level extensions to the operating system , 1998, TOCS.

[23]  Ben Shneiderman,et al.  Designing The User Interface , 2013 .

[24]  Robert E. Kraut,et al.  Interface design and multivariate analysis of UNIX command use , 1984, TOIS.

[25]  Flaviu Cristian,et al.  Exception Handling and Software Fault Tolerance , 1982, IEEE Transactions on Computers.

[26]  Rob Miller,et al.  The Amulet Environment: New Models for Effective User Interface Software Development , 1997, IEEE Trans. Software Eng..

[27]  Ian Holyer,et al.  An Automatic Make Facility , 2000 .

[28]  Gregory D. Abowd,et al.  Giving Undo Attention , 1992, Interact. Comput..

[29]  George B. Leeman A formal approach to undo operations in programming languages , 1986, TOPL.

[30]  Brian Randell,et al.  Reliability Issues in Computing System Design , 1978, CSUR.

[31]  Maurice J. Bach The Design of the UNIX Operating System , 1986 .

[32]  Donald A. Norman,et al.  Design rules based on analyses of human error , 1983, CACM.

[33]  Andrew F. Monk,et al.  Mode Errors: A User-Centered Analysis and Some Preventative Measures Using Keying-Contingent Sound , 1986, Int. J. Man Mach. Stud..

[34]  Rob Pike The text editor sam , 1987, Softw. Pract. Exp..

[35]  Y. Yang Experimental rapid prototyping of undo support , 1990 .

[36]  Thomas Berlage,et al.  The GINA Interaction Recorder , 1992, Engineering for Human-Computer Interaction.

[37]  Harold W. Thimbleby,et al.  User interface design , 1990, ACM Press Frontier Series.

[38]  Glenn S. Fowler The Fourth Generation Make , 1985 .

[39]  Walter H. Kohler,et al.  A Survey of Techniques for Synchronization and Recovery in Decentralized Computer Systems , 1981, CSUR.

[40]  Harold Thimbleby,et al.  Character level ambiguity: consequences for user interface design , 1982 .

[41]  A. G. Hume mk: a successor to make , 1990 .

[42]  Warren Teitelman,et al.  The interlisp reference manual , 1974 .

[43]  Barak A. Pearlmutter,et al.  Detecting intrusions using system calls: alternative data models , 1999, Proceedings of the 1999 IEEE Symposium on Security and Privacy (Cat. No.99CB36344).

[44]  Prasun Dewan,et al.  Multi-User Undo/Redo , 1992 .

[45]  Mary Gray Wish -- A Window-Based Shell for X , 1988 .

[46]  Hiroshi Toriya,et al.  UNDO and REDO Operations for Solid Modeling , 1986, IEEE Computer Graphics and Applications.

[47]  Eric Harslem,et al.  Designing the STAR User Interface , 1987, ECICS.

[48]  James D. Foley,et al.  The art of natural graphic man—Machine conversation , 1974 .

[49]  Michael Spenke,et al.  An overview of GINA—the generic interactive application , 1991 .

[50]  Brian W. Kernighan,et al.  The UNIX™ programming environment , 1979, Softw. Pract. Exp..

[51]  James E. Archer,et al.  COPE: A Cooperative Programming Environment , 1981 .

[52]  Wolfgang Dzida,et al.  The Role of Excursions in Interactive Systems , 1983, Int. J. Man Mach. Stud..

[53]  Steven A. Hofmeyr,et al.  Intrusion Detection via System Call Traces , 1997, IEEE Softw..

[54]  Chris S. McDonald fsh—A functional unix command interpreter , 1987, Softw. Pract. Exp..

[55]  Alan J. Dix,et al.  Dealing with Undo , 1997, INTERACT.

[56]  Richard M. Stallman,et al.  Gnu Emacs Manual , 1996 .

[57]  Steven P. Reiss,et al.  PECAN: Program Development Systems that Support Multiple Views , 1984, IEEE Transactions on Software Engineering.

[58]  Roger Faulkner,et al.  The Process File System and Process Model in UNIX System V , 1991, USENIX Winter.

[59]  John M. Carroll,et al.  Learning to use word processors: problems and prospects , 1983, TOIS.

[60]  Larry Masinter,et al.  The Interlisp Programming Environment , 1981, Computer.

[61]  Willy Zwaenepoel,et al.  Optimistic Make , 1992, IEEE Trans. Computers.

[62]  Thomas Berlage,et al.  From Undo to Multi-User Applications , 1993, VCHCI.

[63]  Allen Newell,et al.  The psychology of human-computer interaction , 1983 .

[64]  Byron Rakitzis,et al.  Es: A shell with higher-order functions , 1993, USENIX Winter.

[65]  Prasun Dewan,et al.  A General Multi-User Undo/Redo Model , 1995, ECSCW.

[66]  Jim S. Briggs Generating reversible programs , 1987, Softw. Pract. Exp..

[67]  William B. Rouse,et al.  Human errors in detection, diagnosis, and compensation for failures in the engine control room of a supertanker , 1981 .

[68]  Andy Oram,et al.  Managing Projects with Make , 1993 .

[69]  Ronald M. Baecker,et al.  The user-centred iterative design of collaborative writing software , 1995 .

[70]  Thomas Berlage,et al.  A framework for shared applications with a replicated architecture , 1993, UIST '93.

[71]  Henry F. Korth,et al.  Oonix: an object-oriented Unix shell , 1989, [1989] Proceedings of the Twenty-Second Annual Hawaii International Conference on System Sciences. Volume II: Software Track.

[72]  D. Endler,et al.  Intrusion detection. Applying machine learning to Solaris audit data , 1998, Proceedings 14th Annual Computer Security Applications Conference (Cat. No.98EX217).

[73]  Fred B. Schneider,et al.  User Recovery and Reversal in Interactive Systems , 1984, TOPL.

[74]  Atul Prakash,et al.  DistEdit: a distributed toolkit for supporting multiple group editors , 1990, CSCW '90.

[75]  P. A. Lee Exception handling in C programs , 1983, Softw. Pract. Exp..

[76]  Irving L. Traiger,et al.  The Recovery Manager of the System R Database Manager , 1981, CSUR.

[77]  Alan Cooper,et al.  About Face: The Essentials of User Interface Design , 1995 .

[78]  Andreas Reuter,et al.  Principles of transaction-oriented database recovery , 1983, CSUR.

[79]  Andries van Dam,et al.  Interactive Editing Systems: Part I , 1982, CSUR.

[80]  Walter F. Tichy,et al.  Rcs — a system for version control , 1985, Softw. Pract. Exp..

[81]  Donald A. Norman,et al.  Stages and Levels in Human-Machine Interaction , 1984, Int. J. Man Mach. Stud..

[82]  Adele Goldberg,et al.  Smalltalk-80 - the interactive programming environment , 1984 .