This paper proposes a strategy for automatically fixing faults in a program by combining the ideas of mutation and fault localization. Statements ranked in order of their likelihood of containing faults are mutated in...
详细信息
This paper proposes a strategy for automatically fixing faults in a program by combining the ideas of mutation and fault localization. Statements ranked in order of their likelihood of containing faults are mutated in the same order to produce potential fixes for the faulty program. The proposed strategy is evaluated using 8 mutant operators against 19 programs each with multiple faulty versions. Our results indicate that 20.70% of the faults are fixed using selected mutant operators, suggesting that the strategy holds merit for automatically fixing faults. The impact of fault localization on efficiency of the overall fault-fixing process is investigated by experimenting with two different techniques, Tarantula and Ochiai, the latter of which has been reported to be better at fault localization than Tarantula, and also proves to be better in the context of fault-fixing using our proposed strategy. Further experiments are also presented to evaluate stopping criteria with respect to the mutant examination process and reveal that a significant fraction of the (fixable) faults can be fixed by examining a small percentage of the program code. We also report on the relative fault-fixing capabilities of mutant operators used and present discussions on future work. (C) 2013 Elsevier Inc. All rights reserved.
Localizing a fault in program debugging is a complex and time-consuming process. In this paper we present a novel approach using execution slices and inter-block data dependency to effectively identify the locations o...
详细信息
Localizing a fault in program debugging is a complex and time-consuming process. In this paper we present a novel approach using execution slices and inter-block data dependency to effectively identify the locations of program faults. An execution slice with respect to a given test case is the set of code executed by this test, and two blocks are data dependent if one block contains a definition that is used by another block or vice versa. Not only can our approach reduce the search domain for program debugging, but also prioritize suspicious locations in the reduced domain based on their likelihood of containing faults. More specifically, we use multiple execution slices to prioritize the likelihood of a piece of code containing a specific fault. In addition, the likelihood also depends oil whether this piece of code is data dependent on other suspicious code. A debugging tool, DESiD, was developed to support our method. A case study that shows the effectiveness of our method in locating faults on an application developed for the European Space Agency is also reported. (c) 2005 Elsevier Inc. All rights reserved.
programmers spend most of their time and resources in localizing program defects. Oil the other hand, they commit many errors by manipulating dynamic data improperly, which may produce dynamic memory problems, such LI...
详细信息
programmers spend most of their time and resources in localizing program defects. Oil the other hand, they commit many errors by manipulating dynamic data improperly, which may produce dynamic memory problems, such LIS dangling pointer, memory leaks, and inaccessible objects. Dangling pointers can occur when a Function returns a pointer to an automatic variable. or when trying to access a deleted object. Inaccessible objects occur when a pointer is assigned to point to another object, leaving the original object inaccessible, either by using the new operator or regular assignment operator. Memory leaks Occur when a dynamic data is allocated but never de-allocated. The existence Of Such dynamic memory problems causes the programs to behave incorrectly. Improper usage of dynamic data is a common defect that is easy to commit, but is difficult to diagnose and discover. In this paper, we propose a dynamic approach that detects different types of program defects including those that occur LIS a result of miusing the dynamic data in Computer programs. Our approach uses the notion of redundant computation to identify the suspicious locations in the program that may contain defects. Redundant computation is all execution of a program statement(s) that does not contribute to the program Output. The notion of redundant computation is introduced as a potential indicator of defects in programs. We investigate the application of redundant computation in debuggingprograms. The detection of redundant computation indicates deficiency that may represent a bug in the program. The results or the experiment show that, the redundant computation detection can help the debuggers to localize the source(s) of the program defects. (C) 2008 Elsevier Inc. All rights reserved.
Automated debugging, i.e., automated fault localization in programs, is an important and challenging problem. In literature the use of AI techniques like model-based diagnosis have been reported in order to solve the ...
详细信息
This study explores students' cognitive processes while debuggingprograms by using an eye tracker. Students' eye movements during debugging were recorded by an eye tracker to investigate whether and how high-...
详细信息
This study explores students' cognitive processes while debuggingprograms by using an eye tracker. Students' eye movements during debugging were recorded by an eye tracker to investigate whether and how high- and low-performance students act differently during debugging. Thirty-eight computer science undergraduates were asked to debug two C programs. The path of students' gaze while following program codes was subjected to sequential analysis to reveal significant sequences of areas examined. These significant gaze path sequences were then compared to those of students with different debugging performances. The results show that, when debugging, high-performance students traced programs in a more logical manner, whereas low-performance students tended to stick to a line-by-line sequence and were unable to quickly derive the program's higher-level logic. Low-performance students also often jumped directly to certain suspected statements to find bugs, without following the program's logic. They also often needed to trace back to prior statements to recall information, and spent more time on manual computation. Based on the research results, adaptive instructional strategies and materials can be developed for students of different performance levels, to improve associated cognitive activities during debugging, which can foster learning during debugging and programming.
program debugging is a critical and complex activity in software engineering. Accurate and fast debugging leads to high quality software and a short time-to-market. debugging involves a very demanding cognitive proces...
详细信息
ISBN:
(纸本)0769521908
program debugging is a critical and complex activity in software engineering. Accurate and fast debugging leads to high quality software and a short time-to-market. debugging involves a very demanding cognitive process. In a case study, we found all six levels of Bloom's taxonomy of cognitive learning, from "knowledge" through "comprehension", "application", "analysis", "synthesis", and "evaluation". The involvement of the higher levels of Bloom's taxonomy, such as synthesis and evaluation, indicates that program debugging is a difficult cognitive task. This fact may explain the difference between novices and experts in debugging effectiveness.
program debugging is a complex cognitive process. Since it is an important step in programming, debug training not only improves learner's programming capacity, but also their problem solving capacity. For the pur...
详细信息
ISBN:
(纸本)9783642313974
program debugging is a complex cognitive process. Since it is an important step in programming, debug training not only improves learner's programming capacity, but also their problem solving capacity. For the purpose of this paper. three C language experts were invited;novices were represented by three third-year students. All six persons participated in a think-aloud experiment, where every person was given two programs to debug;each program was set up to contain three error types, i.e. syntax, semantic and logic. The results showed that experts have a better grasp of feedback from the compiler. On the other hand, experts and novices have similar thinking process in syntax debugging. In semantic debugging, experts are able to comprehend the output results, but novices are rather confused;as to logic debugging, novices are less developed in logical structuring. This paper suggests student's debugging capacity must be reinforced in programming courses, particularly in semantic and logic debugging.
In this paper, we will present two user interfaces we developed for a tutor on debuggingprograms. The second interface is reified with respect to the first, and is hence, better at capturing student misconceptions an...
详细信息
ISBN:
(纸本)0769519679
In this paper, we will present two user interfaces we developed for a tutor on debuggingprograms. The second interface is reified with respect to the first, and is hence, better at capturing student misconceptions and promoting the development of an accurate mental model in the learner. We will discuss the rationale behind the interface, its significance, and its impact on the maintenance of the student model. We will also describe the design and implementation of the reified interface.
Java program debugging was investigated in computer science students who used a software debugging environment (SDE) that provided concurrently displayed, adjacent, multiple and linked representations consisting of th...
详细信息
ISBN:
(纸本)0769516440
Java program debugging was investigated in computer science students who used a software debugging environment (SDE) that provided concurrently displayed, adjacent, multiple and linked representations consisting of the program code, a visualisation of the program, and its output. The aim of this investigation was to address questions such as 'To what extent do programmers use each type of representation ?', 'Are particular patterns of representation use associated with superior debugging performance ?', 'Are graphical representations more helpful to Java programmers than textual ones ?' and 'Are representations that highlight data structure more useful than those that highlight con trol -flow for Java debugging ?' A modified version of the Restricted Focus Viewer (RFV) - a visual attention tracking system - was employed to measure the degree to which each of the representations was used, and to record switches between representations. The experimental results are in agreement with research in the area that suggests that control-flow information is difficult to decode in an Object-Oriented language like Java. These results also suggest that graphical representations might be more useful than textual ones when the degree of difficulty of the debugging task poses a challenge to programmers. Additionally, the results link programming experience to switching behaviour suggesting that although switches between the code and the visualisation are the most common ones, programming experience might promote a more balanced switching behaviour between the main representation, the code, and the secondary ones.
When a bug is detected by testing a quantum program on a quantum computer, we want to determine its location to fix it. To locate the bug, the quantum program is divided into several segments, and each segment is test...
详细信息
ISBN:
(纸本)9798400705007
When a bug is detected by testing a quantum program on a quantum computer, we want to determine its location to fix it. To locate the bug, the quantum program is divided into several segments, and each segment is tested. However, to prepare a quantum state that is input to a segment, it is necessary to execute all the segments ahead of that segment in a quantum computer. This means that the cost of testing each segment depends on its location. We can also locate a buggy segment only if it is confirmed that there are no bugs in all segments ahead of that buggy segment. Since a quantum program is tested statistically on the basis of measurement results, there is a tradeoff between testing accuracy and cost. Although these characteristics are unique to quantum programs and complicate locating bugs, they have not been investigated. We suggest for the first time that these characteristics should be considered to efficiently locate bugs. We are also the first to propose a bug-locating method that takes these characteristics into account. The results from experiments indicate that the bug-locating cost, represented as the number of executed quantum gates, can be reduced with the proposed method compared with naive methods.
暂无评论