scispace - formally typeset
Search or ask a question
Journal ArticleDOI

Reversible execution

01 Sep 1973-Communications of The ACM-Vol. 16, Iss: 9, pp 566
TL;DR: The ability to backtrack, or retrace, the execution of a computer program has gained wider acceptance recently as a desired feature within a programming language.
Abstract: The ability to backtrack, or retrace, the execution of a computer program has gained wider acceptance recently as a desired feature within a programming language. This is particularly useful in two different applications: (1) In debugging systems where the trace output is saved and can be interrogated under programmer control [1, 3]; (2) In artificial intelligence applications where one is trying to prove a certain result. It is frequently necessary to backup the proof and try some alternative path [2].
Citations
More filters
Journal ArticleDOI
TL;DR: The experiment reported here shows that programmers also routinely break programs into one kind of coherent piece which is not coniguous.
Abstract: Computer programmers break apart large programs into smaller coherent pieces. Each of these pieces: functions, subroutines, modules, or abstract datatypes, is usually a contiguous piece of program text. The experiment reported here shows that programmers also routinely break programs into one kind of coherent piece which is not coniguous. When debugging unfamiliar programs programmers use program pieces called slices which are sets of statements related by their flow of data. The statements in a slice are not necessarily textually contiguous, but may be scattered through a program.

813 citations


Cites background from "Reversible execution"

  • ...Zelkowitz [27] reports on the efficacy of a interactive debugger capable of backwards execution....

    [...]

Proceedings Article
10 Apr 2005
TL;DR: Substituted phenol/epichlorohydrin/amine adducts as multipurpose, low concentration additives for hydrocarbon fuels, lubricating oils and mixtures thereof.
Abstract: Operating systems are difficult to debug with traditional cyclic debugging. They are non-deterministic; they run for long periods of time; they interact directly with hard-ware devices; and their state is easily perturbed by the act of debugging. This paper describes a time-traveling virtual machine that overcomes many of the difficulties associated with debugging operating systems. Time travel enables a programmer to navigate backward and forward arbitrarily through the execution history of a particular run and to replay arbitrary segments of the past execution. We integrate time travel into a general-purpose debugger to enable a programmer to debug an OS in reverse, implementing commands such as reverse breakpoint, reverse watchpoint, and reverse single step. The space and time overheads needed to support time travel are reasonable for debugging, and movements in time are fast enough to support interactive debugging. We demonstrate the value of our time-traveling virtual machine by using it to understand and fix several OS bugs that are difficult to find with standard debugging tools. Reverse debugging is especially helpful in finding bugs that are fragile due to non-determinism, bugs in device drivers, bugs that require long runs to trigger, bugs that corrupt the stack, and bugs that are detected after the relevant stack frame is popped.

381 citations


Cites background from "Reversible execution"

  • ...In addition, most reverse debuggers implement time travel by logging all changes to variables [30, 1, 21, 6], and this approach logs too much data when debugging long-running systems such as an OS....

    [...]

  • ...Re-executing prior computation through checkpoint and logging has been discussed in the programming community for many years [30, 10, 1, 4, 6, 24]....

    [...]

Journal ArticleDOI
TL;DR: New blocks frameworks open doors to greater experimentation for novices and professionals alike and provide opportunities for new blocks frameworks to be developed and tested.
Abstract: Blocks-based programming has become the lingua franca for introductory coding. Studies have found that experience with blocks-based programming can help beginners learn more traditional text-based languages. We explore how blocks environments improve learnability for novices by 1) favoring recognition over recall, 2) reducing cognitive load, and 3) preventing errors. Increased usability of blocks programming has led to widespread adoption within introductory programming contexts across a range of ages. Ongoing work explores further reducing barriers to programming, supporting novice programmers in expanding their programming skills, and transitioning to textual programming. New blocks frameworks are making it easier to access a variety of APIs through blocks environments, opening the doors to a greater diversity of programming domains and supporting greater experimentation for novices and professionals alike.

228 citations


Cites background from "Reversible execution"

  • ...The concept of omniscient debugging was first described in the early 1970s as a capability to trace backward in time through execution history to identify the location of the fault that caused a later observed failure [40]....

    [...]

Journal ArticleDOI
TL;DR: New blocks frameworks open doors to greater experimentation for novices and professionals alike as discussed by the authors, which can be used for both novice and professional developers, and can be found in this paper.
Abstract: New blocks frameworks open doors to greater experimentation for novices and professionals alike

174 citations

Proceedings ArticleDOI
07 Mar 2009
TL;DR: This paper introduces, for the first time, a set of abstractions and a software-hardware interface for practical hardware-assisted replay of multiprocessor systems called Capo, and introduces the novel abstraction of the Replay Sphere to separate the responsibilities of the hardware and software components of the replay system.
Abstract: While deterministic replay of parallel programs is a powerful technique, current proposals have shortcomings. Specifically, software-based replay systems have high overheads on multiprocessors, while hardware-based proposals focus only on basic hardware-level mechanisms, ignoring the overall replay system. To be practical, hardware-based replay systems need to support an environment with multiple parallel jobs running concurrently -- some being recorded, others being replayed and even others running without recording or replay. Moreover, they need to manage limited-size log buffers.This paper addresses these shortcomings by introducing, for the first time, a set of abstractions and a software-hardware interface for practical hardware-assisted replay of multiprocessor systems. The approach, called Capo, introduces the novel abstraction of the Replay Sphere to separate the responsibilities of the hardware and software components of the replay system. In this paper, we also design and build CapoOne, a prototype of a deterministic multiprocessor replay system that implements Capo using Linux and simulated DeLorean hardware. Our evaluation of 4-processor executions shows that CapoOne largely records with the efficiency of hardware-based schemes and the flexibility of software-based schemes.

117 citations


Cites background from "Reversible execution"

  • ...First, programmers can use time travel to help debug programs [27, 8, 2, 1, 5, 24], including programs with non-determinism [22, 15], since time travel can provide the illusion of reverse execution and reverse debugging....

    [...]

References
More filters
Proceedings ArticleDOI
R. M. Balzer1
14 May 1969
TL;DR: With the advent of the higher-level algebraic languages, the computer industry expected to be relieved of the detailed programming required at the assembly-language level, but this expectation has largely been realized and many systems are now being built in higher- level languages.
Abstract: With the advent of the higher-level algebraic languages, the computer industry expected to be relieved of the detailed programming required at the assembly-language level. This expectation has largely been realized. Many systems are now being built in higher-level languages (most notably MULTICS).

168 citations

Proceedings ArticleDOI
05 Dec 1972
TL;DR: The design of SAIL follows a tack somewhat different from either of these in the design of LISP2 or FORMULA ALGOL and in its subsequent modifications.
Abstract: Progress in Artificial Intelligence has traditionally been accompanied by advances in special purpose programming techniques and languages. Virtually all of this development has been concentrated in languages and systems oriented to list processing. As the efforts of Artificial Intelligence researchers began to turn from purely symbolic problems toward interaction with the real world, certain features of algebraic languages became desirable. There were several attempts (notably LISP2 and FORMULA ALGOL) to combine the best features of both kinds of language. At the same time, designers of algebraic languages began to include features for non-numerical computation. No new general purpose language without some sort of list processing facility has been suggested for several years. We have followed a tack somewhat different from either of these in the design of SAIL and in its subsequent modifications.

47 citations