Data Flow Diagrams: Reverse Engineering Production and Animation, G. Canfora and L. Sansone and G. Visaggio
@InProceedings{ canfora.sansone.ea:data*1,
author = {G. Canfora and L. Sansone and G. Visaggio},
title = {Data Flow Diagrams: Reverse Engineering Production and
Animation},
booktitle = {CSM'92: Proceedings of the 1992 Conference on Software
Maintenance, {\rm (Orlando, Florida; November 9-12, 1992)}},
year = {November 1992},
pages = {366-375},
publisher = {IEEE Computer Society Press (Order Number 2980)},
abstract = {PITS approach to mapping DFDs to graphics. Interactive
process. Good introduction on used and motivation for RE.},
class = {Software_Reverse_Engineering, Reverse_Specification,
Software_Animation,
Visualization_for_Program_Understanding_and_Debugging }
}
A Framework for the Automated Drawing of Data Structure Diagrams, Chen Ding and Prabhaker Mateti
@Article{ ding.mateti:framework,
author = {Chen Ding and Prabhaker Mateti},
title = {A Framework for the Automated Drawing of Data Structure
Diagrams},
journal = {IEEE Transactions on Software Engineering},
year = {1990},
volume = {16},
number = {5},
pages = {543-557},
month = may,
class = {Software_Reverse_Engineering, Reverse_Specification,
Software_Animation,
Visualization_for_Program_Understanding_and_Debugging}
}
Using Visualization for Architectural Localization and Extraction, Dean Jerding and Spencer Rugaber
Available as
postscript.
@InProceedings{ jerding.rugaber:using,
author = {Dean Jerding and Spencer Rugaber},
title = {Using Visualization for Architectural Localization and
Extraction},
booktitle = {Proceedings of the Fourth Working Conference on Reverse
Engineering},
publisher = {IEEE Computer Society Press Los Alamitos California},
year = {1997},
editor = {Ira Baxter and Alex Quilici and Chris Verhoef},
chapter = {},
pages = {},
address = {},
month = {},
url = {http://www.cc.gatech.edu/morale/papers/isvis_wcre.ps},
abstract = { Understanding the architecture of a program requires
determining both the major components into which the system
is broken and the ways in which the components interact to
accomplish the program's goals. Both static and dynamic
analyses of the software can aid in obtaining this
understanding. This paper describes an analysis technique
for gaining such understanding and a visualization tool
called ISVis that supports it. The technique is applied to
the problem of enhancing the Mosaic web browser by both
visualizing its architecture and finding the components of
the browser into which an enhancement should be inserted.
},
keywords = {software architecture extraction program visualization
dynamic analysis program understanding},
note = {},
class = {Visualization_for_Program_Understanding_and_Debugging
Software_Reverse_Engineering Software_Animation
Reverse_Specification Reverse_Design
Fundamental_Methods_in_Reverse_Design
Recovery_of_Software_Architecture Dynamic_Analysis }
}
Using Visualization to Foster Object-Oriented Program Understanding, Jerding, Dean F. and Stasko, John T.
@TechReport{ jerding.stasko:using,
author = {Jerding, Dean F. and Stasko, John T.},
title = {Using Visualization to Foster Object-Oriented Program
Understanding},
institution = {Graphics, Visualization, and Usability Center Georgia
Institute of Technology, Atlanta, GA},
year = {1994},
type = {Technical Report},
number = {GIT-GVU-94-33},
month = jul,
ftp = {ftp://ftp.cc.gatech.edu/pub/gvu/tech-reports},
class = {Software_Reverse_Engineering, Reverse_Specification,
Software_Animation,
Visualization_for_Program_Understanding_and_Debugging,
Visualizing_Object-Oriented_Programs}
}
Reverse Engineering by visualizing and querying, A. Mendelzon and J. Sametinger
@Article{ mendelzon.sametinger:reverse,
title = {Reverse Engineering by visualizing and querying},
author = {A. Mendelzon and J. Sametinger},
journal = {Software---Concepts and Tools},
pages = {170--182},
volume = {16},
number = {4},
year = {1995},
note = { A tool called Hy+ is described that can be used for
reverse engineering. Hy+ is a general-purpose data
visualization system for querying and visualizing
information about object-oriented software systems. Hy+
supports this for arbitrary graph-like databases. The use
is demonstrated with the evaluation of software metrics,
verifying constraints and identifying design patterns},
class = {Software_Reverse_Engineering, Reverse_Design,
Fundamental_Methods_in_Reverse_Design, Source_Code_Queries,
Reverse_Specification, Software_Animation,
Visualization_for_Program_Understanding_and_Debugging}
}
Applying algorithm animation techniques for program tracing, debugging, and understanding, Sougata Mukherjea and John T. Stasko
@InProceedings{ mukherjea.stasko:applying,
author = {Sougata Mukherjea and John T. Stasko},
title = {Applying algorithm animation techniques for program
tracing, debugging, and understanding},
pages = {456--467},
booktitle = {Proceedings of the 15th International Conference on
Software Engineering },
year = {1993},
publisher = {IEEE Computer Society Press},
month = apr,
abstract = {Algorithm animation which presents a dynamic visualization
of an algorithm or program, primarily has been used as a
teaching aid. The higly abstract, application-specific
nature of algorithm animation requires human design of the
animation views. We speculate that the application-specific
nature of algorithm animation views could be a valuable
debugging aid for software developers as well.
Unfortunately, if animation development requires
time-consuming design with a graphics package, it will not
be used for debugging, where timeliness is a necessity. We
have developed a system called Lens that allows programmers
to rapidly (in minutes) build algorithm animation-style
program views without requiring any sophisticated graphics
knowledge or coding. Lens is integrated with a system
debugger to promote iterative design and exploration.},
class = {Software_Reverse_Engineering, Reverse_Specification,
Software_Animation,
Visualization_for_Program_Understanding_and_Debugging,
Algorithm_Animation}
}
Toward Visual Debugging: Integrating Algorithm Animation Capabilities within a Source Level Debugger, Mukherjea, Sougata and Stasko, John T.
@Article{ mukherjea.stasko:toward,
author = {Mukherjea, Sougata and Stasko, John T.},
title = {Toward Visual Debugging: Integrating Algorithm Animation
Capabilities within a Source Level Debugger},
journal = {ACM Transactions on Computer-Human Interaction},
year = {1994},
volume = {1},
number = {3},
pages = {215-244},
month = sep,
class = {Software_Reverse_Engineering, Reverse_Specification,
Software_Animation,
Visualization_for_Program_Understanding_and_Debugging,
Algorithm_Animation}
}
Incense: A System for Displaying Data Structures, Brad A. Myers
@Article{ myers:incense,
author = {Brad A. Myers},
title = {Incense: A System for Displaying Data Structures},
journal = {Computer Graphics},
year = {1983},
volume = {17},
number = {3},
pages = {115-125},
month = jul,
class = {Software_Reverse_Engineering, Reverse_Specification,
Software_Animation,
Visualization_for_Program_Understanding_and_Debugging}
}
Linked-List Visualization for Debugging, Takao Shimomura and Sadahiro Isoda
@Article{ shimomura.isoda:linked-list,
author = {Takao Shimomura and Sadahiro Isoda},
title = {Linked-List Visualization for Debugging},
journal = {IEEE Software},
year = {1991},
pages = {44-51},
month = may,
class = {Software_Reverse_Engineering, Reverse_Specification,
Software_Animation,
Visualization_for_Program_Understanding_and_Debugging}
}
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 }
}