Decompilation: The Enumeration of Types and Grammars, Peter T. Breuer and Jonathan P. Bowen
@Article{ breuer.bowen:decompilation,
author = {Peter T. Breuer and Jonathan P. Bowen},
title = {Decompilation: The Enumeration of Types and Grammars},
journal = {ACM Transactions on Programming Languages and Systems},
volume = {16},
number = {5},
pages = {1613-1647},
month = {September},
year = {1994},
abstract = { . one of the few papers that discusses decompilation,
from object -> source . authors are with Universidata
Politecnica de Madrid and Oxford . in fact, they describe a
"decompiler compiler", a decompiler generator similar to a
yacc compiler generator! Example used is for occam .
described as an extension to the reverse engineering work
in Eprit II REDO * something to pursue later at the SEI,
esp. for military systems },
class = {Software_Reverse_Engineering, Binary_Reverse_Engineering}
}
Analyzing Java Software by Combining Metrics and Program Visualization, Tarja Systä and Ping Yu and Hausi Müller
Available as
~tsysta.
@InProceedings{ systä.yu.ea:analyzing,
author = {Tarja Systä and Ping Yu and Hausi Müller},
title = {Analyzing Java Software by Combining Metrics and Program
Visualization},
booktitle = {Proceedings of the 4th European Conference on Software
Maintenance and Reengineering (CSMR 2000)},
publisher = {IEEE Computer Society},
year = {2000},
pages = {199-208},
url = {http://www.cs.tut.fi/~tsysta},
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 measures, and then be analyzed and visualized using
scripts through the end-user programmable interface.
Shimba has recently been extended with the Chidamber and
Kemerer suite of object-oriented metrics. The metrics
measure properties of the classes, the inheritance
hierarchy, and the interaction among classes of a subject
system. Since Shimba is primarily intended for the analysis
and exploration of Java software, the metrics have been
tailored to measure properties of software components
written in Java. We show how these metrics can be applied
in the context of understanding software systems using a
reverse engineering environment. The static dependency
graphs of the system under investigation are decorated with
measures obtained by applying the object-oriented metrics
to selected software components. Shimba provides tools to
examine these measures, to find software artifacts that
have values that are in a given range, and to detect
correlations among different measures. The object-oriented
analysis of the subject Java system can be investigated
further by exporting the measures to a spreadsheet. },
keywords = {Java, software metrics, program visualizaton, Rigi},
class = {Binary_Reverse_Engineering Reverse_Design
Reverse_Engineering_Tools
Metric-Based_Methods_in_Reverse_Design Rig
Software_Reverse_Engineering }
}
On the relationships between static and dynamic models in reverse engineering Java software, Tarja Systä
Available as
~tsysta.
@InProceedings{ systä:on,
author = {Tarja Systä},
title = {On the relationships between static and dynamic models in
reverse engineering Java software},
booktitle = {Proceedings of the 6th Working Conference on Reverse
Engineering (WCRE99)},
publisher = {IEEE Computer Society},
year = {1999},
pages = {304-313},
url = {http://www.cs.tut.fi/~tsysta},
abstract = {An experimental environment for reverse engineering Java
software is discussed. Static information is extracted from
class files and viewed using Rigi reverse engineering
environment. The dynamic information is generated by
running the target software under a debugger. The debugged
event trace information is viewed as scenario diagrams
using a prototype tool called SCED. In SCED state diagrams
can be synthesized automatically from scenario diagrams.
Dynamic information can also be attached to the static Rigi
graph. Both static and dynamic views contain information
about software artifacts and their relations. Such
overlapping information forms a connection for information
exchange between the views. SCED scenario diagrams are used
for slicing the Rigi view and the Rigi view, in turn, is
used to guide the generation of SCED scenario diagrams and
for raising their level of abstraction. },
keywords = {Java, SCED, Rigi, static reverse engineering, dynamic
reverse engineering},
class = {Visualization_for_Program_Understanding_and_Debugging
Binary_Reverse_Engineering Software_Animation
Reverse_Specification Visualizing_Object-Oriented_Programs
Reverse_Design Reverse_Engineering_Tools Program_Slicing
Fundamental_Methods_in_Reverse_Design Rigi Dynamic_Analysis
Software_Reverse_Engineering Static_Analysis }
}
Static and Dynamic Reverse Engineering Techniques for Java Software Systems, Tarja Systä
Available as
~tsysta.
@PhDThesis{ systä:static,
author = {Tarja Systä},
title = {Static and Dynamic Reverse Engineering Techniques for Java
Software Systems},
school = {University of Tampere},
year = {2000},
url = {http://www.cs.tut.fi/~tsysta},
keywords = {Java, static reverse engineering, dynamic reverse
engineering, Rigi, SCED, Shimba},
class = {Visualization_for_Program_Understanding_and_Debugging
Binary_Reverse_Engineering Software_Animation
Reverse_Specification Visualizing_Object-Oriented_Programs
Reverse_Design Reverse_Engineering_Tools Program_Slicing
Fundamental_Methods_in_Reverse_Design Rig Dynamic_Analysis
Software_Reverse_Engineering Static_Analysis }
}