The design and implementation of a language-independent, interactive system to facilitate the analysis and symbolic debugging of computer programs written in high-level languages is presented. The principal features of the system, called RAIDE, are: (1) Host source language independence is supported by the abstraction of language entities and constructs (for example, variables, constants, procedures, statements, and events) with a language interfacer providing language-dependent details; (2) Translators can cooperate with RAIDE at varying levels of detail; (3) The user interacts with RAIDE and an executing object program using an extendable debugging language, called Dispel; (4) Primitive debugging actions are kept to a minimum and nonprimitive actions (for example, tracing, snapshots, and postmortem dumping) are provided by user-supplied and library procedures written in Dispel; and (5) The implementation is aided by simulation of a virtual debugging machine, called SPAM. To demonstrate RAIDE's feasibility, a prototype implementation was undertaken, including a SPAM simulator and the modification of two language translators (namely, Asple and BCPL) to interface with RAIDE. Besides describing the external and internal designs of the debugging system, the abstract machine, and the debugging language, the thesis also discusses the advantages and shortcomings of each of these components. Numerous examples of debugging commands written in Dispel are given. Two significant side-effects of the research are reported; reflections on the software tools supporting the implementation, and suggestions for translator design to facilitate run-time debugging. The thesis contains a substantial annotated bibliography and an extensive index. / Science, Faculty of / Computer Science, Department of / Unknown

Novice programmers are difficult to debug on their own because of their lacking of prior knowledge. If we want to help them, first we need to able to check the correctness of a novice¡¦s program. And whenever any error is found, we could provide some suggestion to assist them in debugging. We use concolic testing algorithm to automatically generate test inputs. The test inputs generation of the concolic testing is directed by negating path conditions and is produced by solving path constraints. By using of concolic testing, we are able to explore as much more branches as we can. And once we found an error, we will try to locate it for novice programmers. We propose a new method called concolic debugging. Its idea comes from concolic testing. The concolic debugging algorithm initiates with a given failed test, and try to locate the faulty block by negating and backtracking the path conditions of the failed test. We use concolic testing to improve assessing style of the automated assessment system. 86.67% of our sample programs are successfully assessed by concolic testing algorithm on our new automated assessment system. And we also found our concolic debugging is much more stable and accuracy on fault localization then spectrum-based fault localization.

No description available.

In the arena of software development, implementing a software design (no matter how perfect the design) is rarely done right the first time. Consequently, debugging one's own (or someone else's) software is inevitable, and tools that assist in this often-arduous task become very important with respect to reducing the cost of debugging as well as the cost of the software life cycle as a whole. Many tools exist with this aim, but all are lacking in a key area: information visualization. Applying information visualization techniques such as zooming, focus and context, or graphical representation of numeric data may enhance the visual debugging experience. To this end, drawing data structures as graphs is potentially a step in the right direction, but more must be done to maximize the value of time spent debugging and to minimize the actual amount of time spent debugging. This thesis will address some information visualization techniques that may be helpful in debugging (specifically with respect to visual debugging) and will present the results of a small pilot study intended to illustrate the potential value of such techniques. / Master of Science

Call number: LD2668 .T4 1986 C48 / Master of Science / Computing and Information Sciences

published_or_final_version / Computer Science / Master / Master of Philosophy

No description available.

No description available.

Improving the performance and functionality of contemporary debugging tools is essential to alleviate the debugging task. This dissertation aims at narrowing the gap between current capabilities of debugging tools and industry requirements by improving two important debugging techniques: error trace compaction and automated debugging. Error trace compaction leverages incremental SAT and heuristics to reduce the number of clock cycles required to observe a failure in an error trace. The technique presented reduces the length of the error trace to a minimum while improving performance by 8× compared to a previous technique. The second contribution uses maximum satisfiability to enhance the functionality and performance of automated debuggers. The method proposed can identify where in the design the bug is located and when in the error trace the bug is excited. Compared to a competitive SAT-based approach, our formulation produces problems that are 80% smaller and that can be solved 4.5x faster.

Improving the performance and functionality of contemporary debugging tools is essential to alleviate the debugging task. This dissertation aims at narrowing the gap between current capabilities of debugging tools and industry requirements by improving two important debugging techniques: error trace compaction and automated debugging. Error trace compaction leverages incremental SAT and heuristics to reduce the number of clock cycles required to observe a failure in an error trace. The technique presented reduces the length of the error trace to a minimum while improving performance by 8× compared to a previous technique. The second contribution uses maximum satisfiability to enhance the functionality and performance of automated debuggers. The method proposed can identify where in the design the bug is located and when in the error trace the bug is excited. Compared to a competitive SAT-based approach, our formulation produces problems that are 80% smaller and that can be solved 4.5x faster.