References of Visualization_for_Program_Understanding_and_Debugging

    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 }
    }
    

koschke@informatik.uni-stuttgart.de (Feedback).
Copyright © 1998-2000 University of Stuttgart, Germany. $Revision: 1.5 $
Date: Sun Nov 22 01:00:43 CET 2009