Toward an Infrastructure to Support Interoperability in Reverse Engineering
Nicholas A. Kraft, Brian A. Malloy and James F. Power,12th Working Conference on Reverse Engineering,
Pittsburgh, Pennsylvania, USA, November 8-11, 2005, pp. 196-205.
(c) Copyright 2005, IEEE.
In this paper we present an infrastructure that supports interoperability among various reverse engineering tools and applications. We include an Application Programmer's Interface that permits extraction of information about declarations, including classes, functions and variables, as well as information about scopes, types and control statements in C++ applications. We also present a hierarchy of canonical schemas that capture minimal functionality for middle-level graph structures. This hierarchy facilitates an unbiased comparison of results for different tools that implement the same or a similar schema. We have a repository, hosted by SourceForge.net, where we have placed the artifacts of our infrastructure.
An Analysis of Rule Coverage as a Criterion in Generating Minimal Test Suites for Grammar-Based Software
Mark Hennessy and James F. Power,20th IEEE/ACM International Conference on Automated Software Engineering,
Long Beach, California, USA, November 7-11, 2005, pp. 104-113.
(c) Copyright 2005, ACM.
The term grammar-based software describes software whose input can be specified by a context-free grammar. This grammar may occur explicitly in the software, in the form of an input specification to a parser generator, or implicitly, in the form of a hand-written parser, or other input-verification routines. Grammar-based software includes not only programming language compilers, but also tools for program analysis, reverse engineering, software metrics and documentation generation. Such tools often play a crucial role in automated software development, and ensuring their completeness and correctness is a vital prerequisite for their use. In this paper we propose a strategy for the construction of test suites for grammar based software, and illustrate this strategy using the ISO C++ grammar. We use the concept of rule coverage as a pivot for the reduction of implementation-based and specification-based test suites, and demonstrate a significant decrease in the size of these suites. To demonstrate the validity of the approach, we use the reduced test suite to analyze three grammar-based tools for C++. We compare the effectiveness of the reduced test suite with the original suite in terms of code coverage and fault detection.
Using a Molecular Metaphor to Facilitate Comprehension of 3D Object Diagrams
Brian A. Malloy and James F. Power,IEEE Symposium on Visual Languages and Human-Centric Computing,
Dallas, Texas, USA, September 20-24, 2005, pp. 233-240.
(c) Copyright 2005, IEEE.
This paper presents a strategy for the visualization of dynamic object relationships in Java programs. The metaphor of a chemical molecule is used to aid comprehension, and to help in reducing the size of the object graph. Our strategy has been implemented by dynamically instrumenting Java bytecode to collect trace data, which is then analyzed and visualized in 3D using VRML. Quantitative and graphical results are presented, based on an analysis of programs in the SPEC JVM98 and JOlden benchmark suites.
A method-level comparison of the Java Grande and SPEC JVM98 benchmark suites
David Gregg, James F. Power and John Waldron,Concurrency and Computation: Practice and Experience,
Vol. 17, No. 7-8, June-July, 2005, pp. 757-773.
ISSN: 1532-0626.
(c) Copyright 2005, John Wiley & Sons, Ltd.
In this paper we seek to provide a foundation for the study of the level of use of object-oriented techniques in Java programs in general, and scientific applications in particular. In particular we investigate the profiles of Java programs from a number of perspectives, including the use of class library methods, the size of methods called, the mode of invoke instruction used and the polymorphicity of call sites. We also present a categorisation of the nature of small-sized methods used in Java programs. We compare the Java Grande and SPEC JVM98 benchmark suites, and note a significant difference in the nature and composition of these suites, with the programs from the Java Grande suite demonstrating a less object-oriented approach.
Specifying and Verifying Communications Protocols using Mixed Intuitionistic Linear Logic
David Sinclair and James F. Power,Electronic Notes in Theoretical Computer Science,
Vol. 133, 31 May, 2005, pp. 255-273.
ISSN: 1571-0661.
(c) Copyright 2005, Elsevier B.V..
This paper presents an outline specification of the IP and TCP communication protocols in mixed intuitionistic linear logic and describes how this logic can be used to prove some properties of both protocols. We have previously presented a specification of IP in using commutative linear logic; in this paper we extend this specification considerably to include TCP, which, in turn, necessitates the use of non-commutative operators.
Originally appeared in the Ninth International Workshop on Formal Methods for Industrial Critical Systems, Linz, Austria, September 20-21, 2004
Exploiting UML dynamic object modeling for the visualization of C++ programs
Brian A. Malloy and James F. Power,ACM Symposium on Software Visualization,
St. Louis, Missouri, USA, May 15-16, 2005, pp. 105-114.
ISBN: 1-59593-073-6.
(c) Copyright 2005, ACM.
In this paper we present an approach to modeling and visualizing the dynamic interactions among objects in a C++ application. We exploit UML diagrams to expressively visualize both the static and dynamic properties of the application. We make use of a class diagram and call graph of the application to select the parts of the application to be modeled, thereby reducing the number of objects and methods under consideration with a concomitant reduction in the cognitive burden on the user of our system. We use aspects to insert probes into the application to enable profiling of the interactions of objects and methods and we visualize these interactions by providing sequence and communication diagrams for the parts of the program under consideration. We complement our static selectors with dynamic selectors that enable the user to further filter objects and methods from the sequence and communication diagrams, further enhancing the cognitive economy of our system. A key feature of our approach is the provision for dynamic interaction with both the profiler and the application. Interaction with the profiler enables filtering of methods and objects. Interaction with the application enables the user to supply input to the application to provide direction and enhance comprehension or debugging.
g4re: Harnessing GCC to Reverse Engineer C++ Applications
Nicholas A. Kraft, Brian A. Malloy and James F. Power,Transformation Techniques in Software Engineering: Dagstuhl Seminar Proceedings No. 05161,
IBFI, Schloss Dagstuhl, Germany, April 17-22, 2005.
In this paper, we describe g4re, our tool chain that exploits GENERIC, an intermediate format incorporated into the gcc C++ compiler, to facilitate analysis of real C++ applications. The gcc GENERIC representation is available through a file generated for each translation unit (tu), and g4re reads each tu file and constructs a corresponding Abstract Semantic Graph (ASG). Since tu files can be prohibitively large, ranging from 10 megabytes for a "hello world" program, to 18 gigabytes for a version of Mozilla Thunderbird, we describe our approach for reducing the size of the generated ASG.
Using Object-Level Run-Time Metrics to Study Coupling Between Objects
Aine Mitchell and James F. Power,20th Annual ACM Symposium on Applied Computing,
Santa Fe, New Mexico, March 13 -17, 2005, pp. 1456 - 1462.
ISBN: 1-58113-964-0.
(c) Copyright 2005, ACM.
In this paper we present an investigation into the run-time behaviour of objects in Java programs, using specially adapted coupling metrics. We identify objects from the same class that exhibit non-uniform coupling behaviour when measured dynamically. We define a number of object level run-time metrics, based on the static Chidamber and Kemerer coupling between objects (CBO) measure. These new metrics seek to quantify coupling at different layers of granularity, that is at class-class and object-class level. We outline our method of collecting such metrics and present a study of the programs from the JOlden benchmark suite as an example of their use. A number of statistical techniques, principally agglomerative hierarchical clustering analysis, are used to facilitate the identification of such objects.
A Coverage Analysis of Java Benchmark Suites
Stephen Brown, Aine Mitchell and James F. Power,The IASTED International Conference on Software Engineering,
Innsbruck, Austria, February 15-17, 2005, pp. 144-150.
ISBN: 0-88986-464-0.
(c) Copyright 2005, IASTED.
The Java programming language provides an almost ideal environment for both static and dynamic analysis, being easy to parse, and supporting a standardised, easily-profiled virtual environment. In this paper we study the relationship between results obtainable from static and dynamic analysis of Java programs, and in particular the difficulties of correlating static and dynamic results. As a foundation for this study, we focus on various criteria related to run-time code coverage, as commonly used in test suite analysis. We have implemented a dynamic coverage analysis tool for Java programs, and we use it to evaluate several standard Java benchmark suites using line, instruction and branch coverage criteria. We present data indicating a considerable variance in static and dynamic analysis results between these suites, and even between programs in these suites.
Editorial: Special Issue on the Principles and Practice of Programming in Java
James F. Power and John T. Waldron,Science of Computer Programming,
Vol. 54, No. 1, January, 2005, pp. 1-2.
ISSN: 0167-6423.
(c) Copyright 2005, Elsevier B.V.
It gives us great pleasure to present this special issue, containing papers from the conference on the Principles and Practice of Programming in Java held in Kilkenny City, Ireland, in June 2003. All authors of full papers presented at PPPJ 2003 were invited to submit revised and extended version of their papers for this special issue. These papers were rigorously reviewed, resulting in the six papers presented here.