4D Ariadne the Static Debugger of Java Programs

ACM SIGSOFT Software Engineering Notes, 1983

This paper describes how MAP, a tool for understanding software, combines static analysis, some dynamic features, and an interactive presentation to aid programmers in debugging. Static analysis of the sort produced in optimizing compilers could provide programmers with useful information that they cannot get from dynamic debuggers. The challenge for designers of static analysis tools is to present the information in a useful form.

Proceedings of the Fourth European Conference on Software Maintenance and Reengineering, 2000

Abstract Shimba, a prototype reverse engineering environment, has been built to support the understanding of Java software. Shimba uses Rigi and SCED to analyze, visualize, and explore the static and dynamic aspects, respectively, of the subject system. The static software artifacts and their dependencies are extracted from Java byte code and viewed as directed graphs using the Rigi reverse engineering environment. The static dependency graphs of a subject system can be annotated with attributes, such as software quality ...

This article presents Spoon, a library for the analysis and transformation of Java source code. Spoon enables Java developers to write a large range of domain-specific analyses and transformations in an easy and concise manner. Spoon analyses and transformations are written in plain Java. With Spoon, developers do not need to dive into parsing, to hack a compiler infrastructure, or to master a new formalism.

IEEE Transactions on Software Engineering, 2019

To detect and x bugs and security vulnerabilities, software companies use static analysis as part of the development process. However, static analysis code itself is also prone to bugs. To ensure a consistent level of precision, as analyzed programs grow more complex, a static analysis has to handle more code constructs, frameworks, and libraries that the programs use. While more complex analyses are written and used in production systems every day, the cost of debugging and xing them also increases tremendously. To better understand the di culties of debugging static analyses, we surveyed 115 static analysis writers. From their responses, we extracted the core requirements to build a debugger for static analysis, which revolve around two main issues: (1) abstracting from two code bases at the same time (the analysis code and the analyzed code) and (2) tracking the analysis internal state throughout both code bases. Most current debugging tools that our survey participants use lack the capabilities to address both issues. Focusing on those requirements, we introduce V , a debugging environment for static data-ow analysis that is integrated in the Eclipse development environment. V features graph visualizations that enable users to view the state of a data-ow analysis and its intermediate results at any time. Special breakpoints in V help users step through the analysis code and the analyzed simultaneously. To evaluate the usefulness of V , we have conducted a user study on 20 static analysis writers. Using V helped our sample of analysis writers identify 25% and x 50% more errors in the analysis code compared to using the standard Eclipse debugging environment. CCS CONCEPTS •Software and its engineering → Software testing and debugging; •Theory of computation → Program analysis; •Humancentered computing → Empirical studies in visualization;

Electronic Notes in Theoretical Computer Science, 2005

We present an abstract interpretation framework for a subset of Java (without concurrency). The framework uses a structural abstract domain whose concretization function is parameterized on a relation between abstract and concrete locations. When structurally incomptatible objects may be referred to by the same variable at a given program point, structural information is discarded and replaced by an approximated information about the objects (our presentation concentrates on type information). Plain structural information allows precise intra-procedural analysis but is quickly lost when returning from a method call. To overcome this limitation, relational structural information is introduced, which enables a precise inter-procedural analysis without resorting to inlining. The paper contains an overview of the work. We describe parts of the standard and abstract semantics; then, we briefly explain the fixpoint algorithms used by our implementation; lastly, we provide experimental results for small programs.

Program Visualization …

Given the practical importance and complexity of object-oriented programming, there are many software visualization systems (VSs) for these languages. These systems use different forms of visualization to assist in understanding object-oriented applications. In particular, some VSs are designed to visualize programs written in the Java programming language (and they are often implemented in such a language, too). Java is an attractive language for visualization developers, because it is a "comfortable" language and it is simple to build visualizations in Java. In the particular case of Java VSs implemented in Java itself, there is an additional advantage: the Java Virtual Machine provides an interface to debug programs written in Java, namely JPDA (JPDA). This interface avoids the need of using external debuggers or of generating program traces. The former often involves obscure interfaces; the latter requires to introduce additional code within the target program in order to extract information at run-time.

2007

This paper presents a logic based approach to debugging Java programs. In contrast with traditional debugging we propose a debugging methodology for Java programs using logical queries on individual execution states and also over the history of execution. These queries were arrived at by a systematic study of errors in object-oriented programs in our earlier research. We represent the salient events during the execution of a Java program by a logic database, and implement the queries as logic programs. Such an approach allows us to answer a number of useful and interesting queries about a Java program, such as the calling sequence that results in a certain outcome, the state of an object at a particular execution point, etc. Our system also provides the ability to compose new queries during a debugging session. We believe that logic programming offers a significant contribution to the art of object-oriented programs debugging.

2010 IEEE International Conference on Software Maintenance, 2010

This work presents DDJ, an algorithmic debugger for Java. The main advantage of DDJ with respect to previous algorithmic debuggers is its scalability. DDJ has a new architecture based on the use of cache memories that allows it to scale both in time and memory. In addition, it includes new techniques that allow the debugger to start the debugging session even before the execution tree has been produced. We present the new architecture, and describe the main features of this debugger together with a usage scenario.

… on Advancing the State-of-the- …, 2003

Program analysis plays a key role in many areas of software development, such as performance tuning, testing, debugging, and maintenance. Program analysis can be carried out statically or dynamically, and these two approaches are generally seen as being complementary to each other. In this paper, we will focus on runtime data analysis for object oriented systems in general and the Java 2 platform in particular. More specifically, we are investigating various runtime approaches to monitor the access and modification of variables in a Java program in order to keep track of the their usage history, being of particular interest for dynamic data flow analysis. Our results indicate that the Java 2 platform does not provide sufficient tools to enable comprehensive runtime data analysis in this context, especially when the complete source code of an application under investigation is unavailable.

2012 IEEE 12th International Working Conference on Source Code Analysis and Manipulation, 2012

Large software companies need customized tools to manage their source code. These tools are often built in an ad-hoc fashion, using brittle technologies such as regular expressions and home-grown parsers. Changes in the language cause the tools to break. More importantly, these ad-hoc tools often do not support uncommon-but-valid code code patterns.

In this thesis we describe an approach and introduce a new tool, called JDeTEx, to extract decision tables from Java programs in order to give the maintenance engineer a better understanding of the control flow of the program. Decision tables are a compact, yet precise way to model the control flow of computer programs. In order to extract the decision tables the explicit and implicit control flow of Java programs needs to be analyzed by the tool. Firstly, the tool uses static byte code analysis to automatically extract information about polymorphic method calls that represent implicit control flow in Java programs.Secondly, the tool uses source code analysis to extract information about explicit control flow in the Java program. The main contribution of this thesis is an approach to instrument Java programs in order to extract decision tables from programs. We use the information extracted during byte code and source code analysis to guide the instrumentation process and show that ...

2011

In this article, we present a system intended to help students understand and debug concurrent Java programs. The system instruments Java classes to produce execution traces. These traces can then be used to construct a dynamic dependence graph showing the interactions between the different operations performed in the program. These interactions are used as the basis for an interactive visualisation that can be used to explore the execution of a program and trace incorrect program behaviour back from a symptom to the execution of incorrect code.

Intelligent Problem Solving. …, 2000

JOANA (Java Object-sensitive Analysis) and Java SDG API are analysis frameworks available for analyzing Java programs for different applications. Now a days, the continuous evolution of the customer expectations and requirements has resulted in the increase of size of the software. Due to which the difficulties in maintaining software are increasing. Both Joana and Java SDG API consist of a variety of analysis techniques based on dependence graph generation and computation of slices of an input program. In this paper, we make a comparative analysis study on the effectiveness and efficiency of both these above mentioned analysis frameworks in generating the corresponding intermediate dependence graph and computing slices. The analysis is based on the bytecode of the program under consideration. The experimental analysis shows that Joana can be extended for various diverse applications.

… , 2002. Proceedings. ASE …, 2002

To understand the behavior of a program, a maintainer reads some code, asks a question about this code, conjectures an answer, and searches the code and the documentation for confirmation of her conjecture. However, the confirmation of the conjecture can be error-prone and timeconsuming because the maintainer only has static information at her disposal. She would benefit from dynamic information. In this paper, we present Caffeine, an assistant that helps the maintainer in checking her conjecture about the behavior of a Java program. Our assistant is a dynamic analysis tool that uses the Java platform debug architecture to generate a trace, i.e., an execution history, and a Prolog engine to perform queries over the trace. We present a usage scenario based on the n-queens problem, and two examples based on the Singleton design pattern and on the composition relationship. * This work is partly funded by Object Technology International, Inc. -2670 Queensview Drive -Ottawa, Ontario, K2B 8K1 -Canada Counting the number of immediate backtracks The number of immediate backtracks corresponds to the number of time the algorithm control flow matches the pattern: Control flow enters in method setQueen().