PIGS—A system for programming with interactive graphical support

This paper describes an implementation of a system for programming using structured charts with interactive graphical support. It provides a graphical editor for the user to interactively build and edit programs using Nassi-Shneiderman diagrams (NSD)¹ as the structured control constructs of logic flow. It can interpret a program in NSD chart form, and the execution sequence of the NSD is displayed at a graphical terminal. On-line debugging and testing facilities are available which allow the user to examine and modify the program under execution. The system has been designed with the aim of supporting the development, debugging, testing, documentation and maintenance of programs in the same environment.     

Record manipulation in prolog

Prolog is a relatively new programming language that has proved excellent for symbolic computation. However, Prolog was not specifically designed for industrial scale work and it lacks some standard features that are useful for reading, maintaining and debugging large programs. In particular, Prolog has no record mechanism, and programs often require major changes when data structures are modified. The record is a standard data abstraction concept that improves the robustness of programs. The main advantage in using records is that data structures can be modified and extended with minimal repercussion to program code. Furthermore, the use of significant names to access data fields means that the intent of code is generally clearer. We present a set of primitive operators that support a readable and robust programming style for the manipulation of record data structures in standard Prolog. The proposal covers both simple and imbricated record types and handles selective modification of records cleanly. We also treat property lists and records in a uniform way. These benefits are achieved with minimal overhead while retaining the traditional Prolog non-deterministic style.     

Debugging with dynamic slicing and backtracking

Programmers spend considerable time debugging code. Symbolic debuggers provide some help but the task remains complex and difficult. Other than breakpoints and tracing, these tools provide little high-level help. Programmers must perform many tasks manually that the tools could perform automatically, such as finding which statements in the program affect the value of an output variable for a given test case, and what was the value of a given variable when the control last reached a given program location. If debugging tools provided explicit support for these tasks, the debugging process could be automated to a significant extent. In 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.     

Iterative delta debugging

Automated debugging attempts to locate the reason for a failure. Delta debugging minimizes the difference between two inputs, where one input is processed correctly while the other input causes a failure, using a series of test runs to determine the outcome of applied changes. Delta debugging is applicable to inputs or to the program itself, as long as a correct version of the program exists. However, complex errors are often masked by other program defects, making it impossible to obtain a correct version of the program through delta debugging in such cases. Iterative delta debugging extends delta debugging and removes a series of defects step by step, until the originally unresolved defect is isolated. The method is automated and managed to localize a bug in some real-life examples.     

JP2: Call-site aware calling context profiling for the Java Virtual Machine

Calling context profiling fulfills programmers’ information needs to obtain a complete picture of a program’s inter- and intra-procedural control flow, which are important for workload characterization, debugging, profiling, program comprehension, and reverse engineering. Many existing calling context profilers for Java, however, resort to sampling or other incomplete instrumentation techniques; thus, they collect incomplete profiles only. In this article we present JP2, a new calling context profiler for the Java Virtual Machine, which collects profiles that are not only complete but also call-site aware; that is, JP2 is able to distinguish between multiple call sites within a single method. JP2 supports selective profiling of the dynamic extent of chosen methods and supports profiling of native method invocations. Moreover, produced profiles contain execution statistics at the level of individual basic blocks of code, thereby preserving the intra-procedural control flow of the profiled applications. We rigorously evaluate the overhead incurred by JP2. This overhead is acceptable in tasks such as workload characterization. JP2 is freely available under an Open Source license.     

Guard: A Relative Debugger

A significant amount of software development is evolutionary, involving the modification of already existing programs. To a large extent, the modified 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, verifies the correspondences, and reports any differences 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 different programming languages and executing on different computing platforms. © 1997 by John Wiley & Sons, Ltd.     

The value of slicing while debugging

The paper describes a study that explored the relationship of program slicing to (1) code understanding gained while debugging, and to (2) a debugger's ability to localize the program fault area. The study included two experiments. The first experiment compared the program understanding abilities of two classes of debuggers: those who slice while debugging and those who do not. For debugging purposes, a slice can be thought of as a minimal subprogram of the original code that contains the program faults. Those who only examine statements within a slice for correctness are considered slicers; all others are considered non-slicers. Using accuracy of subprogram construction as a measure of understanding, it was determined that slicers have a better understanding of the code after debugging. The second experiment compared debugger fault localization abilities before and after a training session on how to use slicing in debugging. Using time as a measure of ability, it was shown that slicing while debugging improves a debugger's ability to localize the program fault area.     

基于Eclipse平台的交叉调试方案

Eclipse平台提供了开发C/C++程序的插件CDT,但是针对嵌入式软件的交叉调试,CDT需要过多的用户参与.设计一种基于Eclipse平台的交叉调试方案,通过向Eclipse平台无缝集成交叉调试插件,对调试所需参数进行自动配置,充分利用Eclipse平台的扩展性,使用户可以直观的观察目标机信息,从而实现交叉调试对用户的透明化,达到自动化调试的目的.通过实验表明,该交叉调试方案能够简化用户的控制,提高交叉调试的效率.     

Automated debugging based on a constraint model of the program and a test case

Debugging, i.e., fault localization, in case of a detected failure is a time consuming and intricate task. The automation or at least partial automation of debugging is therefore highly desired. In this paper, we discuss some of the most recent approaches for debugging namely spectrum-based, slicing-based, and model-based debugging. We focus on the latter, and introduce the underlying theory as well as discuss empirical results obtained from our implementation. The model-based approach we present in this paper relies on a constraint representation of a program that is equivalent to the original program in terms of the input-output behavior under some reasonable assumptions. By using constraints for representing programs and subsequently test cases we are able to state the debugging problem as a constraint satisfaction problem that can be effectively solved using a todays constraint solver. The given empirical results indicate that the approach can be used for debugging smaller programs in less than 1 s. Moreover, we briefly compare the three approaches and suggest a combination of them in order to improve the results and the overall necessary running time.     

基于事件结构的并发程序可视化调试方法

在多核和并发技术得到广泛应用的今天,如何有效地调试并发程序,成为一个重要且亟待解决的研究课题.并发程序的不确定性及其行为的复杂性,使得传统的调试技术难以得到有效的应用;而软件维护场景中错误发现与错误调试过程的分离使得错误重现难以实现,面向缺陷报告的调试需求使得自动的错误定位技术难以应用,加剧了调试的困难.针对软件维护阶段由缺陷报告导向的程序调试场景,提出了可视化的并发程序调试方法.该方法能够根据缺陷报告中的信息对程序进行切片,缩小需要分析的代码范围;通过静态分析构造出程序行为的全局视图,帮助程序员发现隐含的程序执行路径;根据事件结构的语义简化程序行为视图,使得行为模型规模可控;根据图形中的分支,引导用户关注路径中的关键操作,从而更快地发现程序中的缺陷.与动态调试方法相比,该方法能够避免错误重现的代价.借助缺陷报告中的信息以及事件结构模型的特点,该方法能够尽量减少状态爆炸的发生.已开发出的交互式并发程序调试工具原型JESVis Debugger,初步实现了所提出的方法.     

Debugging a Distributed Computing System

In this paper we discuss the issues involved in debugging a provide distributed computing system. We describe the major differences between debugging a distributed system and debugging a sequential program. We suggest a methodology for distributed debugging, and we propose various tools or aids.     

Debugging DVM Programs

Facilities for debugging FORTRAN-DVM and C-DVM programs are described. The following approach is used to debug a DVM program. At the first stage, the program is debugged as an ordinary sequential program with the help of conventional debugging facilities. At the second stage, the program is executed on the same computer in a special mode of checking DVM directives. At the third stage, the program can be executed in a special mode when intermediate results of parallel execution are compared with reference results (e.g., those obtained during a sequential execution).     

A situated cognition view about the effects of planning and authorship on computer program debugging

Two experiments were conducted to investigate the relationship between planning and debugging and the effect of program authorship on debugging strategies. Three groups of participants with different programming experiences were recruited. In the first experiment, the participants were asked to develop and debug their self-generated program whereas in the second experiment, they were asked to debug an otherwritten program where some logical errors were planted. Situated cognition approach, being an emergent cognitive paradigm, furnishes an alternative framework to understand the problems of interest. Deweyan notion of inquiry and Gibsonian theory of affordance are of particular relevance. The results show that planning is ineffective for debugging, irrespective of the programming expertise level and program authorship. Besides, situated debugging is demonstrated to be the preferred strategy which is not significantly related to the program authorship. A model of planning for program debugging and a theory of two-faceted transparency are postulated for explicating the observations.     

DENNET中降低调试器干扰的机制

DENNET是清华大学高性能计算所开发的一个机群系统并行程序调试环境．本文分析并行程序调试环境的现状和发展趋势；阐述调试环境对并行程序的干扰问题，指出降低乃至完全消除干扰是并行程序调试环境的一个重要研究方向，介绍了DENNET设计时采用的两种降低干扰的技术．     

A database model of debugging

Debugging a program can be viewed as performing queries and updates on a database that contains program source information as well as the state of the executing program. This approach integrates the facilities of a traditional debugger into a programming environment by providing access to runtime information through normal database query operations. We are building a programming environment in which all program information is stored in a relational database system. This system will include capabilities to provide the programmer a simple yet powerful mechanism for describing debugging requests.     

多核处理器YHFT-QDSP的调试系统

YHFT-QDSP是一款多核处理器。为满足其并发调试和实时调试的需要,在原有单核调试系统的基础上设计实现了多核同步调试系统和片上实时追踪系统（片上Trace）。多核同步调试提供了命令广播和断点同步触发等并发程序协同调试的功能;片上Trace通过专用硬件记录程序执行路径和数据读写等信息实现非入侵实时调试。本文从原理、结构和
软硬件实现等方面介绍了该调试系统。     

Structured debugging using a domain specific language

A structured approach to debugging is presented based on restricting the class of programs that can be written. This is achieved by defining a domain specific language, eliminating control flow by using aggregate operations and eliminating side effects by using an applicative language as a base. The domain specific language is realized by defining domain specific operators as extensions to the base language; a set of operators are defined in the paper for data processing applications. The debugging strategy consists of setting up a sequence of input/output transformations; this process takes the input to the output in partial stages so that the correctness of each transformation relative to its input and output set can be verified. The approach is illustrated by a simple data processing problem.     

An integrated framework for the diagnosis and correction of rule-based programs

We present a generic scheme for the declarative debugging of programs that are written in rewriting-based languages that are equipped with narrowing. Our aim is to provide an integrated development environment in which it is possible to debug a program and then correct it automatically. Our methodology is based on the combination (in a single framework) of a semantics-based diagnoser that identifies those parts of the code that contain errors and an inductive learner that tries to repair them, once the bugs have been located in the program. We develop our methodology in several steps. First, we associate with our programs a semantics that is based on a (continuous) immediate consequence operator, T_R, which models the answers computed by narrowing and is parametric w.r.t. the evaluation strategy, which can be eager or lazy. Then, we show that, given the intended specification of a program R, it is possible to check the correctness of R by a single step of T_R. In order to develop an effective debugging method, we approximate the computed answers semantics of R and derive a finitely terminating bottom-up abstract diagnosis method, which can be used statically. Finally, a bug-correction program synthesis methodology attempts to correct the erroneous components of the wrong code. We propose a hybrid, top-down (unfolding-based) as well as bottom-up (induction-based), correction approach that is driven by a set of evidence examples which are automatically produced as an outcome by the diagnoser. The resulting program is proven to be correct and complete w.r.t. the considered example sets. Our debugging framework does not require the user to provide error symptoms in advance or to answer difficult questions concerning program correctness. An implementation of our debugging system has been undertaken which demonstrates the workability of our approach.     

VS2008的IDE环境中对应用程序进行调试的方法

VS2008是当前软件开发常用的开发环境,其中在VS2008IDE下进行程序的开发,程序开发人员可以很好地利用该开发环境所继承的应用程序调试工具进行程序的调试工作。从对VS2008的开发环境的介绍谈起,就VS2008的IDE环境中对应用程序进行调试的方法进行了说明,最后对VS2008的IDE环境中应用程序进行调试的步骤进行了分析。     

A situated cognition view about the effects of planning and authorship on computer program debugging

Two experiments were conducted to investigate the relationship between planning and debugging and the effect of program authorship on debugging strategies. Three groups of participants with different programming experiences were recruited. In the first experiment, the participants were asked to develop and debug their self-generated program whereas in the second experiment, they were asked to debug an otherwritten program where some logical errors were planted. Situated cognition approach, being an emergent cognitive paradigm, furnishes an alternative framework to understand the problems of interest. Deweyan notion of inquiry and Gibsonian theory of affordance are of particular relevance. The results show that planning is ineffective for debugging, irrespective of the programming expertise level and program authorship. Besides, situated debugging is demonstrated to be the preferred strategy which is not significantly related to the program authorship. A model of planning for program debugging and a theory of two-faceted transparency are postulated for explicating the observations.