Algorithmic Debugging Research Articles

Transmission Line-Planning Method Based on Adaptive Resolution Grid and Improved Dijkstra Algorithm.

An improved Dijkstra algorithm based on adaptive resolution grid (ARG) is proposed to assist manual transmission line planning, shorten the construction period and achieve lower cost and higher efficiency of line selection. Firstly, the semantic segmentation network is used to change the remote sensing image into a ground object-identification image and the grayscale image of the ground object-identification image is rasterized. The ARG map model is introduced to greatly reduce the number of redundant grids, which can effectively reduce the time required to traverse the grids. Then, the Dijkstra algorithm is combined with the ARG and the neighborhood structure of the grid is a multi-center neighborhood. An improved method of bidirectional search mechanism based on ARG and inflection point-correction is adopted to greatly increase the running speed. The inflection point-correction reduces the number of inflection points and reduces the cost. Finally, according to the results of the search, the lowest-cost transmission line is determined. The experimental results show that this method aids manual planning by providing a route for reference, improving planning efficiency while shortening the duration, and reducing the time spent on algorithm debugging. Compared with the comparison algorithm, this method is faster in running speed and better in cost saving and has a broader application prospect.

Design and Simulation Analysis of Simultaneous Localization and Mapping System for Robot Using Multi Photoelectric Sensors

Robot technology integrates motion control, information fusion and wireless communication technology. Among them, simultaneous localization and mapping (SLAM) technology is the key to realize robot autonomous navigation. In this exploration, multi photoelectric sensors are used for information fusion to solve the nonlinear and uncertain problems of robot navigation system in obstacle avoidance. The acoustic optical sensor and photoelectric sensor are integrated to collect the information of the surrounding environment. The photoelectric encoder of the drive motor is used to control the direct current machine with fuzzy PID closed-loop control. The methods of extended Kalman filter based SLAM (EKF-SLAM) and particle filter based SLAM (PF-SLAM), which are commonly used in navigation problems, are studied and compared. The proposed SLAM system adopts ARM11 high performance processor structure of S3C6410. ARM processor is responsible for task management, input and output, acoustic optical sensor can provide distance and position information, and photoelectric sensor can provide two-dimensional plane information. Their information fusion helps to restore the three-dimensional information of the environment around the robot. In the simulation analysis, the robot moves in a circular way on the horizontal ground. SLAM algorithm based on the information fusion of multi photoelectric sensors can help the robot better perceive the surrounding environment in unknown environment, increase the movement distance and reduce the overall positioning error; the robot can avoid obstacles well in autonomous mode after hardware and algorithm debugging. In the remote control mode, the movement of the robot can be adjusted by controlling the direction.

A core Erlang semantics for declarative debugging

One of the main advantages of declarative languages is their clearly established formal semantics, that allows programmers to reason about the properties of programs and to establish the correctness of tools. In particular, declarative debugging is a technique that analyses the proof trees of computations to locate bugs in programs. However, in the case of commercial declarative languages such as the functional language Erlang, sometimes the semantics is only informally defined, and this precludes these possibilities. Moreover, defining semantics for these languages is far from trivial because they include complex features needed in real applications, such as concurrency. In this paper we define a semantics for Core Erlang, the intermediate language underlying Erlang programs. We focus on the problem of concurrency and show how a medium-sized-step calculus, that avoids the details of small-step semantics but still captures the most common program errors, can be used to define an algorithmic debugger that is sound and complete.

Are query-based ontology debuggers really helping knowledge engineers?

Real-world semantic or knowledge-based systems can become large and complex, e.g., in the biomedical domain. Tool support for the localization and repair of faults within knowledge bases of such systems can therefore be essential for their practical success. Correspondingly, a number of knowledge base debugging approaches, in particular for ontology-based systems, were proposed in recent years. Query-based debugging is a comparably recent interactive approach that localizes the true cause of an observed problem by asking knowledge engineers a series of questions. Concrete implementations of this approach exist, such as the OntoDebug plug-in for the ontology editor Protégé.To validate that a newly proposed method is favorable over an existing one, researchers often rely on simulation-based comparisons. Such an evaluation approach however has certain limitations and often cannot fully inform us about a method’s true usefulness. We therefore conducted a range of user studies to assess the practical value of query-based ontology debugging. One main insight from the studies is that the considered interactive approach is indeed more efficient than an alternative algorithmic debugging based on test cases. We also observed that users frequently made errors in the process, which highlights the importance of a careful design of the queries that users need to answer.

Fragment-based spreadsheet debugging

Faults in spreadsheets can represent a major risk for businesses. To minimize such risks, various automated testing and debugging approaches for spreadsheets were proposed. In such approaches, often one main assumption is that the spreadsheet developer is able to indicate if the outcomes of certain calculations correspond to the intended values. This, however, might require that the user performs calculations manually, a process which can easily become tedious and error-prone for more complex spreadsheets. In this work, we propose an interactive spreadsheet algorithmic debugging method, which is based on partitioning the spreadsheet into fragments. Test cases can then be automatically or manually created for each of these smaller fragments, whose correctness or faultiness can be easier assessed by users than test cases that cover the entire spreadsheet. The annotated test cases are then fed into an algorithmic debugging technique, which returns a set of formulas that could have caused any observed failures, i.e., discrepancies between the expected and computed calculation outcomes. Simulation experiments demonstrate that the suggested decomposition approach can speed up the algorithmic debugging process and significantly reduce the number of fault candidates returned by the algorithm. An additional laboratory study shows that fragmenting a spreadsheet with our method furthermore reduces the time needed by users for creating test cases for a spreadsheet.

Declarative debugging of concurrent Erlang programs

Despite the growing number of concurrent applications in nowadays systems, debugging concurrent programs remains an open issue due to its intrinsic complexity. In this work, we present a declarative debugger for the concurrent language Erlang. Following the ideas of algorithmic debugging, our tool asks questions to the user about the validity of transitions between those program points that involve message passing, and also about the expected results of the function calls occurred during the computation. The differences between the user answers, which represent the intended behavior of the program, and the actual program execution, allow the debugger to detect the function responsible for the error, and to point out the pieces of source code responsible for the bugs. The proposal is based on a concurrent calculus for Erlang programs, and we show a benchmark that assesses its scalability both in terms of resources usage and considering the number of questions asked to the user and their complexity. Furthermore, we check the usability of our proposal, applying the debugger to the Erlang library poolboy.

Algorithmic debugging generalized

Algorithmic debugging is a semi-automatic debugging technique that abstracts the operational details of computations, allowing the programmers to debug their code from an abstract point of view. However, its use in practice is still marginal, and one of the reasons is the lack of precision of this technique when reporting errors (current algorithmic debuggers do not point an expression or line as buggy, but they point a whole procedure/function/method as containing the bug). In this paper, we make a step forward to overcome this problem. We identify two specific causes of that problem in the standard formulation and implementations of algorithmic debugging, and we present a reformulation to solve both problems. We show that the novel ideas included in the reformulation proposed cannot be supported by the standard internal data structures (such as the Execution Tree) used in this technique and, hence, a generalisation of the standard definitions and algorithms is needed. The reformulation has been done in a language-independent manner to make it useful and reusable in different programming languages.

A Survey of Algorithmic Debugging

Algorithmic debugging is a technique proposed in 1982 by E. Y. Shapiro in the context of logic programming. This survey shows how the initial ideas have been developed to become a widespread debugging schema fitting many different programming paradigms and with applications out of the program debugging field. We describe the general framework and the main issues related to the implementations in different programming paradigms and discuss several proposed improvements and optimizations. We also review the main algorithmic debugger tools that have been implemented so far and compare their features. From this comparison, we elaborate a summary of desirable characteristics that should be considered when implementing future algorithmic debuggers.

Lightweight computation tree tracing for lazy functional languages

A computation tree of a program execution describes computations of functions and their dependencies. A computation tree describes how a program works and is at the heart of algorithmic debugging. To generate a computation tree, existing algorithmic debuggers either use a complex implementation or yield a less informative approximation. We present a method for lazy functional languages that requires only a simple tracing library to generate a detailed computation tree. With our algorithmic debugger a programmer can debug any Haskell program by only importing our library and annotating suspected functions.

Correctness and Completeness of Logic Programs

We discuss proving correctness and completeness of definite clause logic programs. We propose a method for proving completeness, while for proving correctness we employ a method that should be well known but is often neglected. Also, we show how to prove completeness and correctness in the presence of SLD-tree pruning, and point out that approximate specifications simplify specifications and proofs. We compare the proof methods to declarative diagnosis (algorithmic debugging), showing that approximate specifications eliminate a major drawback of the latter. We argue that our proof methods reflect natural declarative thinking about programs, and that they can be used, formally or informally, in everyday programming.

KGEN: A Python Tool for Automated Fortran Kernel Generation and Verification

Computational kernels, which are small pieces of software that selectively capture the characteristics of larger applications, have been used successfully for decades. Kernels allow for the testing of a compiler's ability to optimize code, performance of future hardware and reproducing compiler bugs. Unfortunately they can be rather time consuming to create and do not always accurately represent the full complexity of large scientific applications. Furthermore, expert knowledge is often required to create such kernels. In this paper, we present a Python-based tool that greatly simplifies the generation of computational kernels from Fortran based applications. Our tool automatically extracts partial source code of a larger Fortran application into a stand-alone executable kernel. Additionally, our tool also generates state data necessary for proper execution and verification of the extracted kernel. We have utilized our tool to extract more than thirty computational kernels from a million-line climate simulation model. Our extracted kernels have been used for a variety of purposes including: code modernization, identification of limitations in compiler optimizations, numerical algorithm debugging, compiler bug reporting, and for procurement benchmarking.

Algorithmic debugging of real-world haskell programs: deriving dependencies from the cost centre stack

Existing algorithmic debuggers for Haskell require a transformation of all modules in a program, even libraries that the user does not want to debug and which may use language features not supported by the debugger. This is a pity, because a promising approach to debugging is therefore not applicable to many real-world programs. We use the cost centre stack from the Glasgow Haskell Compiler profiling environment together with runtime value observations as provided by the Haskell Object Observation Debugger (HOOD) to collect enough information for algorithmic debugging. Program annotations are in suspected modules only. With this technique algorithmic debugging is applicable to a much larger set of Haskell programs. This demonstrates that for functional languages in general a simple stack trace extension is useful to support tasks such as profiling and debugging.

Implementation of an Optimal Strategy for Algorithmic Debugging

One of the most automatic debugging techniques is Algorithmic Debugging because it allows us to debug a program without the need to inspect the source code. In order to find a bug, an algorithmic debugger asks questions to the programmer about the correctness of subcomputations in an execution. Reducing the number and complexity of these questions is an old objective in this field. Recently, an strategy for algorithmic debuggers that minimizes the number of questions has been released. This new strategy is called Optimal Divide and Query and, provided that all questions can be answered, it finds any bug in the source code with a minimum set of questions. In this work we discuss the implementation of such a strategy in different algorithmic debugging architectures.

A survey on algorithmic debugging strategies

Algorithmic debugging is a debugging technique that has been extended to practically all programming paradigms. Roughly speaking, the technique constructs an internal representation of all (sub)computations performed during the execution of a buggy program; and then, it asks the programmer about the correctness of such computations. The answers of the programmer guide the search for the bug until it is isolated by discarding correct parts of the program. After twenty years of research in algorithmic debugging many different techniques have appeared to improve the original proposal. Surprisingly, no study exists that joins together all these techniques and compares their advantages and their performance. This article presents a study that compares all current algorithmic debugging techniques and analyzes their differences and their costs. The research identifies the dimensions on which each strategy relies. This information allows us to combine the strong points of different strategies.

An Innovative Teaching Tool based on Semantic Tableaux for Verification and Debugging of Imperative Programs

While Computational Logic plays an important role in several areas of Computer Science (CS), most educational software developed for teaching logic is not suitable to be used directly in large portions of the CS education domain where the application of logical notions is usually required. In this paper we describe an innovative methodology based on a logic teaching tool on semantic tableaux that has been developed to help students to use logic as a formal proof technique in other advanced topics of CS, such as the verification of algorithms, the algorithmic debugging of programs, and the derivation of algorithms from logical specifications, which are foundations of good development of software. We present the results of the evaluation of this tool by means of several educational experiences during the academic year 2009/2010. From these results we conclude that the use of the tool in current CS teaching can help our students to understand more advanced CS concepts and clarify the formal process involved in the design and analysis of correct and efficient imperative programs.

State of the Practice in Algorithmic Debugging

Algorithmic debugging is a semi-automatic debugging technique which is based on the answers of an oracle (usually the programmer) to a series of questions generated automatically by the algorithmic debugger. The technique typically traverses a record of the execution—the so-called execution tree—which only captures the declarative aspects of the execution and hides operational details. In this work we review and compare the most important algorithmic debuggers of different programming paradigms. In the study we analyze the features incorporated by current algorithmic debuggers, and we identify some features not supported yet by any debugger. We then compare all the debuggers giving rise to a map of the state of the practice in algorithmic debugging.

Hierarchical model building, fitting, and checking: a behind-the-scenes look at a Bayesian analysis of arsenic exposure pathways

In this article, we present a behind-the-scenes look at a Bayesian hierarchical analysis of pathways of exposure to arsenic (a toxic heavy metal) using the Phase I National Human Exposure Assessment Survey carried out in Arizona. Our analysis combines individual-level personal exposure measurements (biomarker and environmental media) with water, soil, and air observations from the ambient environment. We include details of our model-building exercise that involved a combination of exploratory data analysis and substantive knowledge in exposure science. Then we present our strategies for model fitting, which involved piecing together components of the hierarchical model in a systematic fashion to assess issues including parameter identifiability, Bayesian learning, model fit, and convergence diagnostics. We also discuss practical issues of data management and algorithm debugging, especially in the light of missing and censored data. We believe that our presentation of these behind-the-scenes details will be of use to other researchers who build complex Bayesian hierarchical models.

Algorithmic Debugging of Java Programs

In this paper we propose applying the ideas of declarative debugging to the object-oriented language Java as an alternative to traditional trace debuggers used in imperative languages. The declarative debugger builds a suitable computation tree containing information about method invocations occurred during a wrong computation. The tree is then navigated, asking the user questions in order to compare the intended semantics of each method with its actual behavior until a wrong method is found out. The technique has been implemented in an available prototype. We comment the several new issues that arise when using this debugging technique, traditionally applied to declarative languages, to a completely different paradigm and propose several possible improvements and lines of future work.

Hardware/software optimization for array & pointer boundary checking against buffer overflow attacks

Malicious intrusions by buffer overflow attacks cause serious security problems and pose serious threats for networks and distributed systems such as clusters, Grids and P2P systems. Array & pointer boundary checking is one of the most effective approaches for defending against buffer overflow attacks. However, a big performance overhead may occur after boundary checking is applied. Typically, it may cause 2–5 times slowdown [T.M. Austin, E.B. Scott, S.S. Gurindar, Efficient detection of all pointer and array access errors, in: Proceedings of the ACM SIGPLAN ’94 Conference on Programming Language Design and Implementation, 1994, pp. 290–301; R.W.M. Jones, P.H.J. Kelly, Backwards-compatible bounds checking for arrays and pointers in c programs, in: The Third International Workshop on Automated and Algorithmic Debugging, 1997, pp. 13–26]. In this paper, we propose a hardware/software method to optimize the performance of array & pointer boundary checking by designing a special boundary checking instruction. The experimental results show that our method can effectively reduce the overhead of array & pointer boundary checking.

자바 언어를 위한 알고리즈믹 디버깅 기술의 설계

본 논문은 자바 프로그램에서 논리적인 오류를 발견하기 위해 알고리즈믹 디버깅 기술의 이용을 제안한다. 알고리즈믹 디버깅 기술은 원시프로그램으로부터 실행 트리를 생성하고, 실행 트리로부터 프로그램 내에 포함된 논리적인 오류를 하향식 방법으로 발견하는 반자동화 디버깅기술이다. 따라서 알고리즈믹 디버깅 기술은 다양한 프로그래밍 언어에 알맞은 실행 트리를 생성하는 것이 중요하다. 주 논문에서는 자바 프로그램으로부터 실행 트리를 생성하는 방법을 제안하고 예제론 통해서 자바 프로그램을 위한 알고리즈믹 디버깅 기술을 확인한다. 이 접근은 전통적인 순차적 디버깅 기술보다 사용자와 디버깅 시스템 사이에서 상호작용의 수를 줄일 수 있다. This paper proposes to use an algorithmic debugging technique for locating logical errors in Java programs. The algorithmic debugging is a semi-automated debugging technique that builds an execution tree from a source program and locates logical errors, if any, included in the program from the execution tree with top-down method. So, it is very important to build a suitable execution tree from the various programming languages. In this paper we propose the method for building an execution tree iron Java programs and walk through an example. This approach could reduce the number of interactions between a user and a debugging system than the traditional step-wise debugging technique.