Graphical Support for Debugging Parallel Programs (extended abstract), Appelbe, William F. and Kraemer, Eileen and Lakshmanan, Bala and Stasko, John T. and Wehrli, Joseph F.
@InProceedings{ appelbe.kraemer.ea:graphical,
author = {Appelbe, William F. and Kraemer, Eileen and Lakshmanan,
Bala and Stasko, John T. and Wehrli, Joseph F.},
title = {Graphical Support for Debugging Parallel Programs
(extended abstract)},
booktitle = {Proceedings of the 1993 ACM/ONR Workshop on Parallel and
Distributed Debugging, San Diego, CA},
year = {1993},
pages = {172-174},
month = may,
class = {Software_Reverse_Engineering, Reverse_Specification,
Software_Animation,
Visualization_of_Parallel_and_Distributed_Programs}
}
Utilizing Program Visualization and Animation Techniques to Aid Parallel Program Development and Debugging (extended abstract), Appelbe, William F. and Stasko, John T.
@InProceedings{ appelbe.stasko:utilizing,
author = {Appelbe, William F. and Stasko, John T.},
title = {Utilizing Program Visualization and Animation Techniques
to Aid Parallel Program Development and Debugging (extended
abstract)},
booktitle = {Proceedings of the 1991 ACM/ONR Workshop on Parallel and
Distributed Debugging, Santa Cruz, CA},
year = {1991},
pages = {207-209},
month = may,
class = {Software_Reverse_Engineering, Reverse_Specification,
Software_Animation,
Visualization_of_Parallel_and_Distributed_Programs}
}
Assessing Program Visualization Systems as Instructional Aids, Badre, Albert and Beranek, Margaret and Morris, J. Morgan and Stasko, John T.
@TechReport{ badre.beranek.ea:assessing,
author = {Badre, Albert and Beranek, Margaret and Morris, J. Morgan
and Stasko, John T.},
title = {Assessing Program Visualization Systems as Instructional
Aids},
institution = {Graphics, Visualization, and Usability Center, Georgia
Institute of Technology, Atlanta, GA},
year = {1991},
type = {Technical Report},
number = {GIT-GVU-91-23},
month = oct,
ftp = {ftp://ftp.cc.gatech.edu/pub/gvu/tech-reports},
http = {http://www.cc.gatech.edu/gvu/softviz/empir/empir.html},
class = {Software_Reverse_Engineering, Reverse_Specification,
Software_Animation,
Empirical_Studies_of_Software_Visualization}
}
Assessing Program Visualization Systems as Instructional Aids, Badre, Albert and Beranek, Margaret and Morris, J. Morgan and Stasko, John T.
@InProceedings{ badre.beranek.ea:assessing*1,
author = {Badre, Albert and Beranek, Margaret and Morris, J. Morgan
and Stasko, John T.},
title = {Assessing Program Visualization Systems as Instructional
Aids},
booktitle = {Computer Assisted Learning, ICCAL '92, Wolfville, Nova
Scotia, Canada},
year = {1992},
editor = {Ivan Tomek},
pages = {87-99},
publisher = {Lecture Notes in Computer Science},
serie = {602},
month = jun,
class = {Software_Reverse_Engineering, Reverse_Specification,
Software_Animation,
Empirical_Studies_of_Software_Visualization}
}
Data Flow Diagrams: Reverse Engineering Production and Animation, G. Canfora and L. Sansone and G. Visaggio
@InProceedings{ canfora.sansone.ea:data,
author = {G. Canfora and L. Sansone and G. Visaggio},
title = {Data Flow Diagrams: Reverse Engineering Production and
Animation},
pages = {366-375},
booktitle = {Proceedings of the International Conference on Software
Maintenance ~1992},
year = {1992},
publisher = {IEEE Computer Society Press},
month = nov,
abstract = {The paper puts forward the use of interactive animation
techniques as a support to reverse engineering processes
oriented to the synthesis of semantic abstractions.
Starting from Data Flow Diagrams, a formal model - called
Dynamic Data Flow Diagrams (DDFDs) - has been defined,
which can be used for the production of executable models
of a software system. A strategy for the DDFD interactive
animation is also put forward. Finally, the paper describes
a prototype tool for (i) the production of the Dynamic Data
Flow Diagram which models an ADA system starting from the
analysis of the code and (ii) the interactive animation of
such model according to the suggested strategy.},
class = {Software_Reverse_Engineering, Reverse_Specification,
Software_Animation}
}
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 Visual Execution Model for Ada Tasking, Laura K. Dillon
@Article{ dillon:visual,
key = {Dillon, 1993},
author = {Laura K. Dillon},
title = {A Visual Execution Model for Ada Tasking},
journal = { ACM Transactions on Software Engineering and
Methodology},
year = {1993},
volume = {2},
number = {4},
pages = {311-345},
month = oct,
abstract = {A visual execution model for Ada tasking can help
programmers attain a deeper understanding of the tasking
semantics. It can illustrate subtleties in semantic
definitions that are not apparent in natural language
descriptions of Ada tasking, as well as the consequences of
choices made in the language design. We describe a contour
model of Ada tasking that depicts asynchronous tasks
(threads of control), relationships between the
environments in which tasks execute, and the manner in
which tasks interact. The use of this high-level execution
model makes it possible to see what happens during
execution of a program. The paper provides an introduction
to the contour model of Ada tasking and demonstrates its
use.},
class = {Software_Reverse_Engineering, Reverse_Specification,
Software_Animation,
Visualization_of_Parallel_and_Distributed_Programs}
}
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}
}
Toolgest\utzte Codeanalyse von Telekommunikationssoftware\ in Chill, Thomas Gen\ssler and Oliver Ciupke
@TechReport{ genler.ciupke:toolgestutzte,
author = {Thomas Gen{\ss}ler and Oliver Ciupke},
title = {Toolgest{\"u}tzte {C}odeanalyse von
{T}elekommunikationssoftware\ in {C}hill},
institution = {Forschungszentrum Informatik},
year = {1997},
type = {Systemdokumentation und {P}rojektbericht},
class = {Software_Reverse_Engineering, Reverse_Specification,
Software_Animation,
Information_Visualization_and_Visualization_of_Large_Systems}
}
Falcon: On-line Monitoring and Steering of Large-Scale Parallel Programs, Gu, Weiming and Eisenhauer, Greg and Kraemer, Eileen and Schwan, Karsten and Stasko, John T. and Vetter, Jeffrey and Mallavarupu, Nirupama
@TechReport{ gu.eisenhauer.ea:falcon,
author = {Gu, Weiming and Eisenhauer, Greg and Kraemer, Eileen and
Schwan, Karsten and Stasko, John T. and Vetter, Jeffrey and
Mallavarupu, Nirupama},
title = {Falcon: On-line Monitoring and Steering of Large-Scale
Parallel Programs},
institution = {Graphics, Visualization, and Usability Center Georgia
Institute of Technology, Atlanta, GA},
year = {1994},
type = {Technical Report},
number = {GIT-CC-94-21},
month = apr,
ftp = {ftp://ftp.cc.gatech.edu/pub/gvu/tech-reports},
class = {Software_Reverse_Engineering, Reverse_Specification,
Software_Animation,
Visualization_of_Parallel_and_Distributed_Programs}
}
Falcon: On-line Monitoring and Steering of Large-Scale Parallel Programs, Gu, Weiming and Eisenhauer, Greg and Kraemer, Eileen and Schwan, Karsten and Stasko, John T. and Vetter, Jeffrey and Mallavarupu, Nirupama
@InProceedings{ gu.eisenhauer.ea:falcon*1,
author = {Gu, Weiming and Eisenhauer, Greg and Kraemer, Eileen and
Schwan, Karsten and Stasko, John T. and Vetter, Jeffrey and
Mallavarupu, Nirupama},
title = {Falcon: On-line Monitoring and Steering of Large-Scale
Parallel Programs},
booktitle = {Proceedings of the 5th Symposium of the Frontiers of
Massively Parallel Computing, McLean, VA,},
year = {1995},
pages = {422-429},
month = feb,
class = {Software_Reverse_Engineering, Reverse_Specification,
Software_Animation,
Visualization_of_Parallel_and_Distributed_Programs}
}
Animation Support in a User Interface Toolkit: Flexible, Robust and Reusable Abstractions, Hudson, Scott E. and Stasko, John T.
@InProceedings{ hudson.stasko:animation,
author = {Hudson, Scott E. and Stasko, John T.},
title = {Animation Support in a User Interface Toolkit: Flexible,
Robust and Reusable Abstractions},
booktitle = {Proceedings of the 1993 ACM Symposium on User Interface
Software and Technology, Atlanta, GA},
year = {1993},
pages = {57-67},
organization = {ACM},
month = nov,
abstract = {Animation can be a very effective mechanism to convey
information in visualization and user interface settings.
However, integrating animated presentations into user
interfaces has typically been a difficult task since, to
date, there has been little or no explicit support for
animation in window systems or user interface toolkits.
This paper describes how the Artkit user interface toolkit
has been extended with new animation support abstractions
designed to overcome this problem. These abstractions
provide a powerful but convenient base for building a range
of animations, supporting techniques such as simple
motion-blur, "squash and stretch", use of arcing
trajectories, anticipation and follow through, and "slow-in
/ slow-out" transitions. Because these abstractions are
provided by the toolkit they are reusable and may be freely
mixed with more conventional user interface techniques. In
addition, the Artkit implementation of these abstractions
is robust in the face of systems (such as the X Window
System and Unix) which can be ill-behaved with respect to
timing considerations.},
class = {Software_Reverse_Engineering, Reverse_Specification,
Software_Animation, Animation_in_User_Interfaces}
}
Animation Support in a User Interface Toolkit: Flexible, Robust and Reusable Abstractions, Hudson, Scott E. and Stasko, John T.
@TechReport{ hudson.stasko:animation*1,
author = {Hudson, Scott E. and Stasko, John T.},
title = {Animation Support in a User Interface Toolkit: Flexible,
Robust and Reusable Abstractions},
institution = {Graphics, Visualization, and Usability Center, Georgia
Institute of Technology},
year = {1993},
type = {Technical Report},
number = {GIT-GVU-93-17},
address = {Atlanta, GA},
ftp = {ftp://ftp.cc.gatech.edu/pub/gvu/tech-reports},
http = {http://www.cc.gatech.edu/gvu/softviz/uianim/uianim.html},
class = {Software_Reverse_Engineering, Reverse_Specification,
Software_Animation, Animation_in_User_Interfaces}
}
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 }
}
The Information Mural: A Technique for Displaying and Navigating Large Information Spaces, Dean F. Jerding and John T. Stasko
@Article{ jerding.stasko:information,
author = {Dean F. Jerding and John T. Stasko},
title = {The Information Mural: A Technique for Displaying and
Navigating Large Information Spaces},
journal = {Proceedings of the IEEE Symposium on Information
Visualization},
year = {1995},
month = nov,
class = {Software_Reverse_Engineering, Reverse_Specification,
Software_Animation, Visualizing_Object-Oriented_Programs,
Information_Visualization_and_Visualization_of_Large_Systems}
}
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}
}
Issues in Visualization for the Comprehension of Parallel Programs, Eileen Kraemer and John T. Stasko
@InProceedings{ kraemer.stasko:issues,
author = {Eileen Kraemer and John T. Stasko},
title = {Issues in Visualization for the Comprehension of Parallel
Programs},
booktitle = {Third Workshop on Program Comprehension},
publisher = {IEEE Computer Society Press},
address = {Washington, D.C.},
month = nov,
year = {1994},
pages = {116-127},
abstract = {Parallel and distributed computers are becoming more
widely used. Thus, the comprehension of parallel programs
is more challenging than understanding serial programs
because of the issues of concurrency, scale,
communications, shared ressources, and shared state. In
this article, we argue that the use of visualization and
animations of programs can be an invaluable asset to
program comprehension. We present example problems and
visualizations, showing how graphical displays can assist
program understanding. We also describe the Animation
Choreographer, a tool that helps programmers better
comprehend the temporal characteristics of their
programs.},
ftp = {ftp.cc.gatech.edu//pub/groups/reverse/repository/vis.parallel.ps}
,
class = {Software_Reverse_Engineering, Reverse_Specification,
Software_Animation,
Visualization_of_Parallel_and_Distributed_Programs}
}
Toward Flexible Control of the Temporal Mapping from Concurrent Program Events to Animations, Kraemer, Eileen and Stasko, John T.
@InProceedings{ kraemer.stasko:toward,
author = {Kraemer, Eileen and Stasko, John T.},
title = {Toward Flexible Control of the Temporal Mapping from
Concurrent Program Events to Animations},
booktitle = {Proceedings of the 8th International Parallel Processing
Symposium (IPPS '94), Cancun, Mexico},
year = {1994},
pages = {902-908},
month = apr,
class = {Software_Reverse_Engineering, Reverse_Specification,
Software_Animation,
Visualization_of_Parallel_and_Distributed_Programs}
}
The Visualization of Parallel Systems: An Overview, Kraemer, Eileen and Stasko, John T.
@Article{ kraemer.stasko:visualization,
author = {Kraemer, Eileen and Stasko, John T.},
title = {The Visualization of Parallel Systems: An Overview},
journal = {Journal of Parallel and Distributed Computing},
year = {1993},
volume = {18},
number = {2},
pages = {105-117},
month = jun,
class = {Software_Reverse_Engineering, Reverse_Specification,
Software_Animation,
Visualization_of_Parallel_and_Distributed_Programs}
}
Empirically Evaluating the Use of Animations to Teach Algorithms, Lawrence, Andrea and Badre, Albert and Stasko, John T.
@TechReport{ lawrence.badre.ea:empirically,
author = {Lawrence, Andrea and Badre, Albert and Stasko, John T.},
title = {Empirically Evaluating the Use of Animations to Teach
Algorithms},
institution = {Graphics, Visualization, and Usability Center Georgia
Institute of Technology, Atlanta, GA},
year = {1994},
type = {Technical Report},
number = {GIT-GVU-94-07},
month = mar,
ftp = {ftp://ftp.cc.gatech.edu/pub/gvu/tech-reports},
http = {http://www.cc.gatech.edu/gvu/softviz/algoanim/algoanim.html}
,
class = {Software_Reverse_Engineering, Reverse_Specification,
Software_Animation, Algorithm_Animation,
Empirical_Studies_of_Software_Visualization}
}
Empirically Evaluating the Use of Animations to Teach Algorithms, Lawrence, Andrea and Badre, Albert and Stasko, John T.
@InProceedings{ lawrence.badre.ea:empirically*1,
author = {Lawrence, Andrea and Badre, Albert and Stasko, John T.},
title = {Empirically Evaluating the Use of Animations to Teach
Algorithms},
booktitle = {Proceedings of the 1994 IEEE Symposium on Visual
Languages, St. Louis, MO},
year = {1994},
pages = {48-54},
month = oct,
class = {Software_Reverse_Engineering, Reverse_Specification,
Software_Animation, Algorithm_Animation,
Empirical_Studies_of_Software_Visualization}
}
Visualizing Program Dependencies, P. Linos
Available as
~care.
@Article{ linos:visualizing,
author = {P. Linos},
title = {Visualizing Program Dependencies},
journal = {Software-Practice and Experience},
year = {1994},
volume = {24},
number = {4},
pages = {387-403},
url = {http://www.csc.tntech.edu/~care},
abstract = {This paper addresses the problem of visualizing program
dependencies(i.e. enitities and their relations). A code
visualization tool that maintains a repository of
structural and functional dependencies for C programs is
described. Visualization of such dependencies is
accomplished by using a presentation model which combines
data and control flow information. Moreover, transformation
mechanisms and partitioning techniques used by the tool
provide the means for managing large graphical
representations. The quantitative results from an
experimental study using this tool indicate that the
productivity of its users was increased and that the
quality of changes made during a program modification
exercise was improved. Furthermore, the qualitative results
have shown that its presentation model, transformation
mechanisms and partitioning techniques constitute a
promising platform for the comprehension and maintenancce
of C programs. Finally, the outcome of an empirical
evaluation of the tool and hte enhancement of its
functionality and user interface are also discussed in this
paper.},
keywords = {Program understanding Re-engineering Software maintenance
dependencies Layout Tools},
class = {Software_Reverse_Engineering Software_Animation
Reverse_Specification
Empirical_Studies_of_Software_Visualization }
}
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}
}
Visualizing Program Executions on Large Data Sets Using Semantic Zooming, Muthukumarasamy, Jeyakumar and Stasko, John T.
@TechReport{ muthukumarasamy.stasko:visualizing,
author = {Muthukumarasamy, Jeyakumar and Stasko, John T.},
title = {Visualizing Program Executions on Large Data Sets Using
Semantic Zooming},
institution = {Graphics, Visualization, and Usability Center Georgia
Institute of Technology, Atlanta, GA},
year = {1995},
type = {Technical Report},
number = {GIT-GVU-95-02},
month = jan,
ftp = {ftp://ftp.cc.gatech.edu/pub/gvu/tech-reports},
http = {http://www.cc.gatech.edu/gvu/softviz/infoviz/infoviz.html}
,
class = {Software_Reverse_Engineering, Reverse_Specification,
Software_Animation,
Visualization_of_Parallel_and_Distributed_Programs,
Algorithm_Animation,
Information_Visualization_and_Visualization_of_Large_Systems}
}
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}
}
Program Visualization: The Art of Mapping Programs to Pictures, G. C. Roman and K. C. Cox
@InProceedings{ roman.cox:program,
author = {G. C. Roman and K. C. Cox},
title = {Program Visualization: The Art of Mapping Programs to
Pictures},
booktitle = {Proceedings of the 14th International Conference on
Software Engineering },
pages = {412--420},
month = may,
year = {1992},
abstract = {Program visualization is defined as a mapping from
programs to graphical representations. Simple forms of
program visualization are frequently encountered in
software engineering. For this reason current advances in
program visualization are likely to influence future
developments concerning software engineering tools and
environments. The authors provide a new taxonomy of program
visualization research. The proposed taxonomy becomes the
vehicle through which they carry out a systematic review of
current systems, techniques, trends, and ideas in program
visualization.},
class = {Software_Reverse_Engineering, Reverse_Specification,
Software_Animation}
}
A Taxonomy of Program Visualization Systems, Gruia-Catalin Roman and Kenneth C. Cox
@Article{ roman.cox:taxonomy,
author = {Gruia-Catalin Roman and Kenneth C. Cox},
title = {A Taxonomy of Program Visualization Systems},
journal = {IEEE Computer},
year = {1993},
pages = {11-24},
month = dec,
class = {Software_Reverse_Engineering, Reverse_Specification,
Software_Animation}
}
Using Animation to Design, Document and Trace Object-Oriented Systems, Shilling, John J. and Stasko, John T.
@TechReport{ shilling.stasko:using,
author = {Shilling, John J. and Stasko, John T.},
title = {Using Animation to Design, Document and Trace
Object-Oriented Systems},
institution = {Graphics, Visualization, and Usability Center Georgia
Institute of Technology, Atlanta, GA},
year = {1992},
type = {Technical Report},
number = {GIT-GVU-92-12},
address = {Atlanta, GA},
month = jun,
ftp = {ftp://ftp.cc.gatech.edu/pub/gvu/tech-reports},
class = {Software_Reverse_Engineering, Reverse_Specification,
Software_Animation, Visualizing_Object-Oriented_Programs}
}
Using Animation to Design Object-Oriented Systems, Shilling, John J. and Stasko, John T.
@Article{ shilling.stasko:using*1,
author = {Shilling, John J. and Stasko, John T.},
title = {Using Animation to Design Object-Oriented Systems},
journal = {Object Oriented Systems},
year = {1994},
volume = {1},
number = {1},
pages = {5-19},
month = sep,
class = {Software_Reverse_Engineering, Reverse_Specification,
Software_Animation, Visualizing_Object-Oriented_Programs}
}
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}
}
Utilizing Program Visualization Techniques to Aid Parallel and Distributed Program Development, Stasko, John T. and Appelbe, William F. and Kraemer, Eileen
@TechReport{ stasko.appelbe.ea:utilizing,
author = {Stasko, John T. and Appelbe, William F. and Kraemer,
Eileen},
title = {Utilizing Program Visualization Techniques to Aid Parallel
and Distributed Program Development},
institution = {Graphics, Visualization, and Usability Center Georgia
Institute of Technology, Atlanta, GA},
year = {1991},
type = {Technical Report},
number = {GIT-GVU-91/08},
month = jun,
ftp = {ftp://ftp.cc.gatech.edu/pub/gvu/tech-reports},
class = {Software_Reverse_Engineering, Reverse_Specification,
Software_Animation,
Visualization_of_Parallel_and_Distributed_Programs}
}
Do Algorithm Animations Assist Learning? An Empirical Study and Analysis, Stasko, John T. and Badre, Albert and Lewis, Clayton
@InProceedings{ stasko.badre.ea:do,
author = {Stasko, John T. and Badre, Albert and Lewis, Clayton},
title = {Do Algorithm Animations Assist Learning? An Empirical
Study and Analysis},
booktitle = {Proceedings of the INTERCHI '93 Conference on Human
Factors in Computing Systems, Amsterdam, Netherlands},
year = {1993},
pages = {61-66},
month = apr,
class = {Software_Reverse_Engineering, Reverse_Specification,
Software_Animation, Algorithm_Animation,
Empirical_Studies_of_Software_Visualization}
}
A Methodology for Building Application-Specific Visualizations of Parallel Programs, Stasko, John T. and Kraemer, Eileen
@TechReport{ stasko.kraemer:methodology,
author = {Stasko, John T. and Kraemer, Eileen},
title = {A Methodology for Building Application-Specific
Visualizations of Parallel Programs},
institution = {Graphics, Visualization, and Usability Center Georgia
Institute of Technology, Atlanta, GA},
year = {1992},
type = {Technical Report},
number = {GIT-GVU-92-10},
month = jun,
ftp = {ftp://ftp.cc.gatech.edu/pub/gvu/tech-reports},
class = {Software_Reverse_Engineering, Reverse_Specification,
Software_Animation,
Visualization_of_Parallel_and_Distributed_Programs}
}
A Methodology for Building Application-Specific Visualizations of Parallel Programs, Stasko, John T. and Kraemer, Eileen
@Article{ stasko.kraemer:methodology*1,
author = {Stasko, John T. and Kraemer, Eileen},
title = {A Methodology for Building Application-Specific
Visualizations of Parallel Programs},
journal = {Journal of Parallel and Distributed Computing},
year = {1993},
volume = {18},
number = {2},
pages = {258-264},
month = jun,
class = {Software_Reverse_Engineering, Reverse_Specification,
Software_Animation,
Visualization_of_Parallel_and_Distributed_Programs}
}
Toward Flexible Control of the Temporal Mapping from Concurrent Program Events to Animations, Stasko, John T. and Kraemer, Eileen
@TechReport{ stasko.kraemer:toward,
author = {Stasko, John T. and Kraemer, Eileen},
title = {Toward Flexible Control of the Temporal Mapping from
Concurrent Program Events to Animations},
institution = {Graphics, Visualization, and Usability Center Georgia
Institute of Technology, Atlanta, GA},
year = {1994},
type = {Technical Report},
number = {GIT-GVU-94-10},
month = mar,
ftp = {ftp://ftp.cc.gatech.edu/pub/gvu/tech-reports},
class = {Software_Reverse_Engineering, Reverse_Specification,
Software_Animation,
Visualization_of_Parallel_and_Distributed_Programs}
}
Tidy Animations of Tree Algorithms, Stasko, John T. and Turner, Carlton Reid
@TechReport{ stasko.turner:tidy,
author = {Stasko, John T. and Turner, Carlton Reid},
title = {Tidy Animations of Tree Algorithms},
institution = {Graphics, Visualization, and Usability Center Georgia
Institute of Technology, Atlanta, GA},
year = {1992},
type = {Technical Report},
number = {GIT-GVU-92-11},
month = jun,
ftp = {ftp://ftp.cc.gatech.edu/pub/gvu/tech-reports},
http = {http://www.cc.gatech.edu/gvu/softviz/algoanim/algoanim.html}
,
class = {Software_Reverse_Engineering, Reverse_Specification,
Software_Animation, Algorithm_Animation}
}
Tidy Animations of Tree Algorithms, Stasko, John T. and Turner, Carlton Reid
@InProceedings{ stasko.turner:tidy*1,
author = {Stasko, John T. and Turner, Carlton Reid},
title = {Tidy Animations of Tree Algorithms},
booktitle = {Proceedings of the 1992 IEEE Workshop on Visual Languages,
Seattle, WA},
year = {1992},
pages = {216-218},
month = sep,
class = {Software_Reverse_Engineering, Reverse_Specification,
Software_Animation, Algorithm_Animation}
}
Three-Dimensional Computation Visualization, Stasko, John T. and Wehrli, Joseph F.
@TechReport{ stasko.wehrli:three-dimensional,
author = {Stasko, John T. and Wehrli, Joseph F.},
title = {Three-Dimensional Computation Visualization},
institution = {Graphics, Visualization, and Usability Center Georgia
Institute of Technology, Atlanta, GA},
year = {1992},
type = {Technical Report},
number = {GIT-GVU-92-20},
month = sep,
http = {http://www.cc.gatech.edu/gvu/softviz/3dcv/3dcv.html},
ftp = {ftp://ftp.cc.gatech.edu/pub/gvu/tech-reports},
class = {Software_Reverse_Engineering, Reverse_Specification,
Software_Animation, 3D_Computation_Visualization}
}
Three-Dimensional Computation Visualization, Stasko, John T. and Wehrli, Joseph F.
@InProceedings{ stasko.wehrli:three-dimensional*1,
author = {Stasko, John T. and Wehrli, Joseph F.},
title = {Three-Dimensional Computation Visualization},
booktitle = {Proceedings of the 1993 IEEE Symposium on Visual
Languages, Bergen, Norway},
year = {1993},
pages = {100-107},
month = aug,
class = {Software_Reverse_Engineering, Reverse_Specification,
Software_Animation, 3D_Computation_Visualization}
}
Animating Algorithms with XTANGO, Stasko, John T.
@Article{ stasko:animating,
author = {Stasko, John T.},
title = {Animating Algorithms with XTANGO},
journal = {SIGACT News},
year = {1992},
volume = {23},
number = {2},
month = {Spring},
pages = {67-71},
class = {Software_Reverse_Engineering, Reverse_Specification,
Software_Animation, Algorithm_Animation}
}
Animation in User Interfaces: Principles and Techniques, Stasko, John T.
@Article{ stasko:animation,
author = {Stasko, John T.},
title = {Animation in User Interfaces: Principles and Techniques},
journal = {Trends in Software, Special issue on User Interface
Software},
year = {1993},
editor = {Bass, Len and Dewan, Prasun},
number = {1},
chapter = {5},
pages = {81-101},
class = {Software_Reverse_Engineering, Reverse_Specification,
Software_Animation, Animation_in_User_Interfaces}
}
The PARADE Environment for Visualizing Parallel Program Executions: A Progress Report, Stasko, John T.
@TechReport{ stasko:parade,
author = {Stasko, John T.},
title = {The PARADE Environment for Visualizing Parallel Program
Executions: A Progress Report},
institution = {Graphics, Visualization, and Usability Center Georgia
Institute of Technology, Atlanta, GA},
year = {1995},
type = {Technical Report},
number = {GIT-GVU-95-03},
month = jan,
ftp = {ftp://ftp.cc.gatech.edu/pub/gvu/tech-reports},
class = {Software_Reverse_Engineering, Reverse_Specification,
Software_Animation,
Visualization_of_Parallel_and_Distributed_Programs}
}
The Path-Transition Paradigm: A Practical Methodology for Adding Animation to Program Interfaces, Stasko, John T.
@Article{ stasko:path-transition,
author = {Stasko, John T.},
title = {The Path-Transition Paradigm: A Practical Methodology for
Adding Animation to Program Interfaces},
journal = {Journal of Visual Languages and Computing},
year = {1990},
volume = {1},
number = {3},
month = sep,
pages = {213-236},
class = {Software_Reverse_Engineering, Reverse_Specification,
Software_Animation, Algorithm_Animation}
}
TANGO: A Framework and System for Algorithm Animation, Stasko, John T.
@Article{ stasko:tango,
author = {Stasko, John T.},
title = {TANGO: A Framework and System for Algorithm Animation},
journal = {IEEE Computer},
year = {1990},
month = sep,
pages = {27-39},
volume = {23},
number = {9},
class = {Software_Reverse_Engineering, Reverse_Specification,
Software_Animation, Algorithm_Animation}
}
Using Direct Manipulation to Build Algorithm Animations by Demonstration, Stasko, John T.
@InProceedings{ stasko:using,
author = {Stasko, John T.},
title = {Using Direct Manipulation to Build Algorithm Animations by
Demonstration},
booktitle = {Proceedings of the ACM SIGCHI '91 Conference on Human
Factors in Computing Systems, New Orleans, LA},
year = {1991},
month = may,
pages = {307-314},
class = {Software_Reverse_Engineering, Reverse_Specification,
Software_Animation, Algorithm_Animation}
}
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 }
}
Integrating Visualization Support into Distributed Computing Systems, Topol, Brad and Stasko, John T. and Sunderam, Vaidy
@InProceedings{ topol.stasko.ea:integrating*1,
author = {Topol, Brad and Stasko, John T. and Sunderam, Vaidy},
title = {Integrating Visualization Support into Distributed
Computing Systems},
booktitle = {Proceedings of the 15th International Conference on
Distributed Computing Systems, Vancouver, B.C.},
year = {1995},
pages = {19-26},
month = may,
class = {Software_Reverse_Engineering, Reverse_Specification,
Software_Animation,
Visualization_of_Parallel_and_Distributed_Programs}
}
Interactive Three-Dimensional Visual Debugging in Massively Parallel Computation (extended abstract), Wehrli, Joseph F. and Stasko, John T.
@InProceedings{ wehrli.stasko:interactive,
author = {Wehrli, Joseph F. and Stasko, John T.},
title = {Interactive Three-Dimensional Visual Debugging in
Massively Parallel Computation (extended abstract)},
booktitle = {Proceedings of the 1993 ACM/ONR Workshop on Parallel and
Distributed Debugging, San Diego, CA},
year = {1993},
pages = {235-237},
month = may,
class = {Software_Reverse_Engineering, Reverse_Specification,
Software_Animation,
Visualization_of_Parallel_and_Distributed_Programs,
3D_Computation_Visualization}
}
Visualizing the Execution of Threads-based Parallel Programs, Zhao, Qiang A. and Stasko, John T.
@TechReport{ zhao.stasko:visualizing,
author = {Zhao, Qiang A. and Stasko, John T.},
title = {Visualizing the Execution of Threads-based Parallel
Programs},
institution = {Graphics, Visualization, and Usability Center Georgia
Institute of Technology, Atlanta, GA},
year = {1995},
type = {Technical Report},
number = {GIT-GVU-95-01},
month = jan,
ftp = {ftp://ftp.cc.gatech.edu/pub/gvu/tech-reports},
class = {Software_Reverse_Engineering, Reverse_Specification,
Software_Animation,
Visualization_of_Parallel_and_Distributed_Programs}
}