Firebug Research

From FirebugWiki

Revision as of 22:43, 28 October 2009 by Johnjbarton (Talk | contribs)
Jump to: navigation, search

Papers related to Firebug.

Sorry for the lack of formatting, I'll come back and clean up as soon as I can.

Cryptographic Verification of Test Coverage Claims Premkumar Thomas Devanbu, Stuart G. Stubblebine February 2000

IEEE Transactions on Software Engineering , Volume 26 Issue 2 Publisher: IEEE Press

Compact source code printing.

Science of Computer Programming archive Volume 72 , Issue 1-2 (June 2008) table of contents Pages 40-51 Year of Publication: 2008 ISSN:0167-6423 Authors Stoney Jackson Deptartment of Computer Science and Information Technology, Western New England College, 1215 Wilbraham Rd., Springfield, MA 01119, United States Premkumar Devanbu Deptartment of Computer Science, University of California, Davis, One Shields Ave., Davis, CA 95616, United States Kwan-Liu Ma Deptartment of Computer Science, University of California, Davis, One Shields Ave., Davis, CA 95616, United States Publisher Elsevier North-Holland, Inc. Amsterdam, The Netherlands, The Netherlands

Debugging with diffs


   author = {Rok Sosic and David Abramson},
   title = {Guard: A relative debugger},
   journal = {Software Practice and Experience},
   year = {1997},
   volume = {27},
   pages = {94--21}

} A signi cant amount of software development isevolutionary, involving the modi cation of already existing programs. To a large extent, the modi ed programs produce the same results as the original program. This similarity between the original program and the development program is utilized by relative debugging. Relative debugging is a new concept that enables the user to compare the execution of two programs by specifying the expected correspondences between their states. A relative debugger concurrently executes the programs, veri es the correspondences, and reports any di erences found. We describe our novel debugger, called Guard, and its relative debugging capabilities. Guard is implemented by using our library of debugging routines, called Dynascope, which provides debugging primitives in heterogeneous networked environments. To demonstrate the capacity of Guard for debugging in heterogeneous environments, we describe an experiment in which the execution of two programs is compared across Internet. The programs are written in di erent programming languages and executing on di erent computing platforms


   author = {Andreas Zeller},
   title = {Isolating Cause-Effect Chains from Computer Programs},
   year = {2002}

} Consider the execution of a failing program as a sequence of program states. Each state induces the following state, up to the failure. Which variables and values of a program state are relevant for the failure? We show how the Delta Debugging algorithm isolates the relevant variables and values by systematically narrowing the state difference between a passing run and a failing run---by assessing the outcome of altered executions to determine wether a change in the program state makes a difference in the test outcome. Applying Delta Debugging to multiple states of the program automatically reveals the cause-effect chain of the failure---that is, the variables and values that caused the failure.


   author = {Hiralal Agrawal and Richard A. Demillo and Eugene H. Spafford},
   title = {Debugging with Dynamic Slicing and Backtracking},
   journal = {Software Practice and Experience},
   year = {1993},
   volume = {23},
   pages = {589--616}


this paper we present a debugging model, based on dynamic program slicing and execution backtracking techniques, that easily lends itself to automation. This model is based on experience with using these techniques to debug software. We also present a prototype debugging tool, SPYDER, that explicitly supports the proposed model, and with which we are performing further debugging research


   author = {Ronald A. Olsson and Richard H. Crawford and W. Wilson Ho},
   title = {A Dataflow Approach to Event-based Debugging},
   journal = {Software - Practice and Experience},
   year = {1991},
   volume = {21},
   pages = {209--229}


This paper describes a novel approach to event-based debugging. The approach is based on a (coarsegrained) dataflow view of events: a high-level event is recognized when an appropriate combination of lower-level events on which it depends has occurred. Event recognition is controlled using familiar programming language constructs. This approach is more flexible and powerful than current ones. It allows arbitrary debugger language commands to be executed when attempting to form higher-level events. It also allows users to specify event recognition in much the same way that they write programs. This paper also describes a prototype, Dalek, that employs the dataflow approach for debugging sequential programs. Dalek demonstrates the feasibility and attractiveness of the dataflow approach. One important motivation for this work is that current sequential debugging tools are inadequate. Dalek contributes toward remedying such inadequacies by providing events and a powerful debugging language


   author = {Andrew Whitaker and Richard S. Cox and Steven D. Gribble},
   title = {Configuration Debugging as Search: Finding the Needle in the Haystack},
   booktitle = {In OSDI},
   year = {2004},
   pages = {77--90}

} This work addresses the problem of diagnosing configuration errors that cause a system to function incorrectly. For example, a change to the local firewall policy could cause a network-based application to malfunction. Our approach is based on searching across time for the instant the system transitioned into a failed state. Based on this information, a troubleshooter or administrator can deduce the cause of failure by comparing system state before and after the failure. We present the Chronus tool, which automates the task of searching for a failure-inducing state change. Chronus takes as input a user-provided software probe, which differentiates between working and non-working states. Chronus performs “time travel ” by booting a virtual machine off the system’s disk state as it existed at some point in the past. By using binary search, Chronus can find the fault point with effort that grows logarithmically with log size. We demonstrate that Chronus can diagnose a range of common configuration errors for both client-side and server-side applications, and that the performance overhead of the tool is not prohibitive. 1


   author = {Timothy C. Lethbridge and Nicolas Anquetil},
   title = {Architecture of a Source Code Exploration Tool: A Software Engineering Case Study},
   institution = {},
   year = {1997}

} We discuss the design of a software system that helps software engineers (SE's) to perform the task we call just in time comprehension (JITC) of large bodies of source code. We discuss the requirements for such a system and how they were gathered by studying SE's at work. We then analyze our requirements with respect to other tools available to SE's for the JITC task. Next, we walk through system design and the objectoriented analysis process for our system, discussing key design issues. Some issues, such as dealing with multi-part names and conditional compilation are unexpectedly complex. 1 Introduction The goal of our research is to develop tools to help software engineers (SE's) more effectively maintain software. By analyzing the work of SE's, we have come to the conclusion that they spend a considerable portion of their time exploring source code, using a process that we call justin time program comprehension. As a result of our analysis, we have developed a set of requirements.. Practical Object-Oriented Back-in-Time Debugging

         Adrian Lienhard, Tudor Gˆrba and Oscar Nierstrasz

Abstract. Back-in-time debuggers are extremely useful tools for identifying the causes of bugs. Unfortunately the “omniscient” approaches that try to remember all previous states are impractical because they consume too much space or they are far too slow. Several approaches rely on heuristics to limit these penalties, but they ultimately end up throwing out too much relevant information. In this paper we propose a practical approach that attempts to keep track of only the relevant data. In contrast to other approaches, we keep object history information together with the regular objects in the application memory. Although seemingly counter- intuitive, this approach has the effect that data not reachable from current appli- cation objects (and hence, no longer relevant) is garbage collected. We describe the technical details of our approach, and we present benchmarks that demon- strate that memory consumption stays within practical bounds. Furthermore, the performance penalty is significantly less than with other approaches.

Personal tools