Debugging is a significant part of programming. However, a lot of introductory pro- gramming classes tend to focus on writing and reading code than on debugging. They utilize programming assignments that are designed in ways such that students learn debugging by completing these assignments which makes debugging more of an im- plicit goal. In this thesis, we propose a cognitive awareness scaffolding in debugging to help students self-regulate their debugging process. We validate its effectiveness by conducting experiments with students in four sections of a Data Structures course, which is one of the introductory computer science classes at California Polytechnic State University, San Luis Obispo. In this form, students identified the debugging stage, described the bugs in their own words, and tracked their attempts to fix them. The exit survey responses that students filled out at the end of the quarter indi- cate that students seemed to find the debugging form helpful with self-regulation in debugging process. For further investigation, we attempt to measure students’ under- standing of the bugs explained on the form. Additionally, we also discuss potential improvements for the debugging form.

Finding errors in applications has been achieved using a wide variety of techniques. Some tools instrument the application to check for program properties dynamically whereas others analyze the program statically. We use a technique that analyzes a program's execution by binary runtime instrumentation. Unlike tools that work on a particular language or an intermediate representation of a language, our approach works directly on binaries and hence it is not bound to any language. In order to instrument binaries, we use a binary instrumentation system called Pin, which provides APIs to instrument the application at runtime. We have built an infrastructure using Pin called Top that allows program entities like variables and events to be traced. Using finite automata we can check if certain events take place during the execution of the program. Top consists of a Tracing System that can trace movement of pointers to memory locations or 32-bit data values and keeps track of all their copies. It also provides an Event Framework that reports the occurrence of events such as function calls or returns. Top provides a programming interface which allows querying for particular events. The query is compiled with Top to produce a customized analysis tool, also called client. Running the analysis tool with the application, under Pin, results in events of interest being detected and reported. Using Top, we built a Memory Checker that checks for incorrect usage of dynamic memory allocation APIs and semantically incorrect accesses to dynamically allocated memory. Since we perform fine-grained checking by tracing references, our memory checker found some errors that a popular memory checker called valgrind did not. We have also built an MPI Checker which is used to check if programs use MPI's asynchronous communication primitives properly. This checker can detect errors related to illegal data buffer accesses and errors where the programmer inadvertently overwrote a handle needed to finish the processing of a request. / Master of Science

Computer networks are engineered for performance and flexibility, delivering billions of packets per second with high reliability, until they fail. It is during such time of crisis that debugging and troubleshooting come to the forefront, however, the focus on performance results in design tradeoffs that make it challenging to troubleshoot them. This dissertation hypothesizes that a view of the network as a single entity solves the above problems, without compromising either performance or visibility. The primary contributions are 1) a topology oblivious network abstraction for performance monitoring and troubleshooting, 2) transformation of the network abstract query to device local semantics, 3) optimizations for reducing state collection overhead, and 4) global state semantics in the proposed query language easing expression of network queries. Abstracting the entire system as an entity simplifies the debugging process, making possible comprehensive root-cause analysis and exonerating the network administrator from dealing with many devices, delivering gains in productivity and efficiency. By merging network topology information with state collection, this thesis provides a new way to look at the network monitoring and troubleshooting problem. Such an amalgamation allows the translation of a performance query expressed in a domain specific language to small pieces of code operating on different devices in the network collecting necessary state. This merging results in lesser overhead per switch and reduces the strain on devices and provides a simple abstraction to the administrator. / PHD / Computer networks are complex and therefore take a tremendous amount of effort to operate in an efficient and error-free manner. This dissertation presents a mechanism that allows the operator to ignore many intricate details about the network and concentrate on how to fix problems. Such an approach enables automatic methods to facilitate the operator to focus on most relevant information. Saving time, money and resources when operating large networks.

Program Visualization systems use graphics and animation to represent the behavior of software programs. These systems represent different aspects of the program such as source code, control flow, data structures, runtime state of the program. Representing the actual runtime state of the program finds its use in a variety of applications including program understanding, visual debugging, and pedagogy. However, existing state-of-the-art program visualization systems are limited in : (1) not providing sufficient interactive capabilities to the user; (2) not faithfully representing the runtime state of the program; (3) not allowing users to apply different layout strategies to the visualization; (4) being tied to a specific programming language. To address these limitations, this thesis presents HDPV, a program state visualization system that visualizes any C, C++, or Java program. HDPV is based on a canonical state model that represents the memory layout of the program as a graph of memory blocks. It decouples the visualization of the program from the actual programming language in which it is written, thereby making the system language independent. HDPV supports a host of interactive features that allow the user to selectively explore different parts of the program's runtime state. Novel layout strategies support customization through user interaction. We provide a list of use-cases to show that HDPV can be applied to a wide variety of applications including - but not limited to - understanding programs that use basic concepts in computer science, demonstrating algorithm implementations, and debugging software programs. / Master of Science

<p>A significant part of the software development effort is spent on detecting deviations between software implementations and specifications, and subsequently locating the sources of such errors. This thesis illustrates that is possible to identify a significant number of errors during static analysis of declarative object-oriented equation-based modeling languages that are typically used for system modeling and simulation. Detecting anomalies in the source code without actually solving the underlying system of equations provides a significant advantage: a modeling error can be corrected before trying to get the model compiled or embarking on a computationally expensive symbolic or numerical solution process. The overall objective of this work is to demonstrate that debugging based on static analysis techniques can considerably improve the error location and error correcting process when modeling with equation-based languages.</p><p>A new method is proposed for debugging of over- and under-constrained systems of equations. The improved approach described in this thesis is to perform the debugging process on the flattened intermediate form of the source code and to use filtering criteria generated from program annotations and from the translation rules. Each time when an error is detected in the intermediate code and the error fixing solution is elaborated, the debugger queries for the original source code before presenting any information to the user. In this way, the user is exposed to the original language source code and not burdened with additional information from the translation process or required to inspect the intermediate code.</p><p>We present the design and implementation of debugging kernel prototypes, tightly integrated with the core of the optimizer module of a Modelica compiler, including details of the novel framework required for automatic debugging of equation-based languages.</p><p>This thesis establishes that structural static analysis performed on the underlying system of equations from object-oriented mathematical models can effectively be used to statically debug real Modelica programs. Most of our conclusions developed in this thesis are also valid for other equation-based modeling languages.</p> / Report code: LiU-Tek-Lic-2002:37.

Reverse execution can be defined as a method which recovers the states that a program attains during its execution. Therefore, reverse execution eliminates the need for repetitive program restarts every time a bug location is missed. This potentially shortens debug time considerably. This thesis presents a new approach which, for the first time ever (to the best of the author's knowledge), achieves reverse execution at the assembly instruction level on general purpose processors via execution of a reverse program. A reverse program almost always regenerates destroyed states rather than restoring them from a record. Furthermore, a reverse program provides assembly instruction by assembly instruction execution in the backward direction. This significantly reduces state saving and thus decreases the associated memory and time costs of reverse execution support. Furthermore, this thesis presents a new dynamic slicing algorithm that is built on top of assembly instruction level reverse execution. Dynamic slicing is a technique which isolates the code parts that influence an erroneous variable at a program point. The algorithm presented in this thesis achieves dynamic slicing via execution of a reduced reverse program. A reduced reverse program is obtained from a full reverse program by omitting the instructions that recover states irrelevant to the dynamic slice under consideration. This provides a reverse execution capability along a designated dynamic slice only. The use of a reduced reverse program for dynamic slicing removes the need for runtime execution trajectories. The methodology of this thesis has been implemented on a PowerPC processor with a custom made debugger. As compared to previous work, all of which heavily use state saving techniques, the experimental results show up to 2206X reduction in runtime memory usage, up to 403X reduction in forward execution time overhead and up to 2.32X reduction in forward execution time for the tested benchmarks. Measurements on the selected benchmarks also indicate that the dynamic slicing method presented in this thesis can achieve up to six orders of magnitude (1,928,500X) speedups in reverse execution along the dynamic slice as compared to full-scale reverse execution.

This dissertation evaluates the following thesis statement: Program analysis techniques can enable and support the debugging of failures in widely-used applications by (1) capturing, replaying, and, as much as possible, anonymizing failing executions and (2) highlighting subsets of failure-inducing inputs that are likely to be helpful for debugging such failures. To investigate this thesis, I developed techniques for recording, minimizing, and replaying executions captured from users' machines, anonymizing execution recordings, and automatically identifying failure-relevant inputs. I then performed experiments to evaluate the techniques in realistic scenarios using real applications and real failures. The results of these experiments demonstrate that the techniques can reduce the cost and difficulty of debugging.

Thesis (M.S.)--Oregon State University, 2010. / Printout. Includes bibliographical references (leaves 48-51). Also available on the World Wide Web.

One of the most expensive and time-consuming components of the debugging process is locating the errors or faults. To locate faults, developers must identify statements involved in failures and select suspicious statements that might contain faults. In practice, this localization is done by developers in a tedious and manual way, using only a single execution, targeting only one fault, and having a limited perspective into a large search space. The thesis of this research is that fault localization can be partially automated with the use of commonly available dynamic information gathered from test-case executions in a way that is effective, efficient, tolerant of test cases that pass but also execute the fault, and scalable to large programs that potentially contain multiple faults. The overall goal of this research is to develop effective and efficient fault localization techniques that scale to programs of large size and with multiple faults. There are three principle steps performed to reach this goal: (1) Develop practical techniques for locating suspicious regions in a program; (2) Develop techniques to partition test suites into smaller, specialized test suites to target specific faults; and (3) Evaluate the usefulness and cost of these techniques. In this dissertation, the difficulties and limitations of previous work in the area of fault-localization are explored. A technique, called Tarantula, is presented that addresses these difficulties. Empirical evaluation of the Tarantula technique shows that it is efficient and effective for many faults. The evaluation also demonstrates that the Tarantula technique can loose effectiveness as the number of faults increases. To address the loss of effectiveness for programs with multiple faults, supporting techniques have been developed and are presented. The empirical evaluation of these supporting techniques demonstrates that they can enable effective fault localization in the presence of multiple faults. A new mode of debugging, called parallel debugging, is developed and empirical evidence demonstrates that it can provide a savings in terms of both total expense and time to delivery. A prototype visualization is provided to display the fault-localization results as well as to provide a method to interact and explore those results. Finally, a study on the effects of the composition of test suites on fault-localization is presented.

Verifying the reliability and functionality of a complex system like a trading system is highly demanding since failure in such a system can cause serious economic problems. Automated random testing is a good solution to find new and rare failures in such a system. Test cases in random testing usually contain a long sequence of actions that debugging them manually to find the root cause of the failure is a very boring and tiresome task. This thesis aims to create a model for automating the task of the debugging to reduce the failed test case to an equivalent test case that only contains relevant actions that together cause the failure. Delta debugging is the core algorithm of the model that simplifies a failed test case by successive testing. The target of the project is TRADExpress system of Cinnober Financial Technology AB. The model is integrated to the random testing framework of the TRADExpress system.