References of Reverse_Specification

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

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

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

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

@TechReport{	  biggerstaff:nature,
  author	= {Ted J. Biggerstaff},
  title		= {The Nature of Semi-Formal Information in Domain Models},
  institution	= {MCC},
  year		= {1988},
  type		= {Technical Report},
  number	= {STP-289-88},
  month		= sep,
  abstract	= {This position paper describes the nature and importance of
		  informal and semi-formal information in the understanding,
		  interpretation and reuse of large complex programs. The
		  understanding of large, complex, existing programs is
		  sometimes called the "dusty deck" problem.
		  
		  The emphasis of this research is on how one might create a
		  model of a domain that would help in the job of
		  understanding and eventually reusing large scale designs
		  from large, comple and generally unmastered existing
		  programs. The role of informal and semi-formal information
		  is central to this domain model.},
  class		= {Software_Reverse_Engineering, Reverse_Specification,
		  Domain_Analysis}
}

@InProceedings{	  boldyreff.burd.ea:greater,
  author	= {C. Boldyreff and E.L. Burd and R.M. Hather and M. Munro
		  and E.J. Younger},
  title		= {Greater Understanding Through Maintainer Driven
		  Traceability},
  booktitle	= {WPC~'96: Proceedings of the IEEE Fourth Workshop on
		  Program Comprehension, {\rm (Berlin, Germany; March 29-31,
		  1996)}},
  year		= {March 1996},
  publisher	= {IEEE Computer Society Press},
  class		= {Software_Reverse_Engineering, Reverse_Specification,
		  Requirement_Tracability }
}

@Article{	  breuer.lano:creating,
  author	= { P.T. Breuer and K. Lano },
  title		= { Creating Specifications from Code: Reverse-engineering
		  Techniques },
  journal	= {Journal of Software Maintenance: Research and Practice},
  volume	= { 3 },
  year		= { 1991 },
  pages		= { 145-162 },
  abstract	= { },
  class		= {Software_Reverse_Engineering, Reverse_Specification }
}

@Article{	  canfora.cimitile.ea:reverse,
  author	= {G. Canfora and Aniello Cimitile and De Carlini, Ugo},
  title		= {Reverse Engineering and Data Flow Diagrams in ADA
		  Environment},
  journal	= {Microprocessing and Microprogramming},
  year		= {1990},
  volume	= {30},
  pages		= {357-364},
  class		= {Software_Reverse_Engineering, Reverse_Specification,
		  Model_Generating}
}

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

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

@InProceedings{	  debaud.moopen.ea:domain,
  author	= {Jean-Marc DeBaud and Bijith Moopen and Spencer Rugaber},
  title		= {Domain Analysis and Reverse Engineering},
  pages		= {326-335},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1994},
  year		= {1994},
  publisher	= {IEEE Computer Society Press},
  month		= sep,
  abstract	= {Current reverse engineering technology is typically based
		  on program analysis methods such as parsing and data flow
		  analysis. As such, it is limited in what it can accomplish.
		  Knowledge of the applicaton domain containing a program can
		  help overcome this limit and aid the comprehension process.
		  This paper discusses the relationship of application domain
		  analysis and reverse engineering. Two case studies are
		  presented. The first describes how domain knowledge,
		  expressed as an object-oriented framework, can aid the
		  reverse engineering process for a well-understood domain.
		  The second studies how reverse engineering can be used to
		  build a domain model. Issues raised by the confluence of
		  domain analysis and reverse engineering are discussed, and
		  implications on future work in the area are suggested.},
  class		= {Software_Reverse_Engineering, Reverse_Specification,
		  Domain_Analysis}
}

@InProceedings{	  debaud.rugaber:software,
  author	= {Jean-Marc DeBaud and Spencer Rugaber},
  title		= {A Software Re-engineering Method Using Domain Models},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1995},
  address	= {Opio (Nice), France},
  year		= {1995},
  month		= oct,
  pages		= {204-213},
  abstract	= {Current software re-engineering technology is typically
		  based on program analysis methods such as parsing and data
		  flow analysis. This is inadequate for two reasons. First,
		  such methods inherently fail to capture the context or
		  purpose of the program. Second, the results of the program
		  comprehension are not directly usable in program evolution.
		  In this paper, we introduce a method that addresses both of
		  these problems. We use a domain model to understand the
		  context of a program and an object-oriented framework to
		  record that understanding. The main step of this method
		  consists of the construction of an executable domain model
		  whose scope covers a family of target programs. A program
		  is then reverse engineered using the domain model both as a
		  guide and as a recording medium. In the last step,
		  developers re-engineer the target artifact using its
		  abstract domain-driven representation. We present a
		  thorough example to illustrate this approach. Issues raised
		  by the confluence of domain analysis and representation,
		  reverse engineering, and artifact evolution are discussed.
		  Implications on future work in the area are suggested. },
  keywords	= {Program re-engineering, domain analysis, reverse
		  engineering, program evolution, program understanding,
		  reuse infrastructure, software architecture,
		  object-oriented framework.},
  ftp		= {ftp.cc.gatech.edu//pub/groups/reverse/repository/repwrt.ps}
		  ,
  class		= {Software_Reverse_Engineering, Reverse_Specification,
		  Domain_Analysis}
}

@InProceedings{	  debaud:dare,
  author	= {Jean-Marc DeBaud},
  title		= {DARE: Domain-Augmented ReEngineering},
  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},
  abstract	= {We present in this article the principles of a
		  domain-augmented reengineering approach (DARE) as well as
		  our initial experience applying sections of it. The
		  principal characteristic of the DARE approach is its focus
		  upon the computational context of a software system i.e.
		  the business or scientific domain to which it relates. This
		  context information is used both to drive the program
		  understanding as well as for the program evolution phases
		  of reengineering. In DARE a domain model (concepts and
		  associated relationships) serves as the structure denoting
		  context and is used for two purposes. First a dictionary of
		  possible domain concept realizations is populated. Second a
		  set of mappings from the domain to an existing tool or
		  library related to the domain is defined. Reengineering
		  then proceeds as follows: First a legacy system is analyzed
		  and annotated with the dictionary of domain concept
		  realizations. Then these matched concepts are transitioned
		  to the tool or library using the predefined mapping set.
		  Program evolution can then take place at the level of the
		  tool or library. Using our initial experience we discuss
		  DARE present an analysis and suggest implications for
		  future work.},
  class		= {Software_Evolution Software_Reverse_Engineering
		  Model_Generating Reverse_Specification Reverse_Design
		  Domain_Analysis Process_Models_for_Reverse_Design
		  Knowledge-Based_Concept_Assignmen }
}

@InProceedings{	  debaud:lessons,
  author	= {Jean-Marc DeBaud},
  title		= {Lessons from a Domain-Based Reengineering Effort},
  booktitle	= {Proceedings of Working Conference on Reengineering},
  year		= {1996},
  abstract	= {We present in this paper the lessons and insights learned
		  from of a domain-centered reengineering effort. Using a
		  method we developed in a previous work, we set about to
		  understand and transition a complete legacy system from
		  COBOL to an executable domain model. Our work suggests that
		  a domain-based approach is very promising but a number of
		  issues remain to be better understood. Among these are
		  questions about domain completeness, scoping, interleaving
		  and evolution; concept matching at the granularity of both
		  the programs' architecture and the details of the
		  source-code; thoroughness and representation of the legacy
		  programs coverage, as well as the problems inherent to the
		  transition of a multi-programs system. We discuss these
		  issues in details using examples. Implications on future
		  work in the area are suggested.},
  class		= {Software_Reverse_Engineering, Reverse_Specification,
		  Domain_Analysis}
}

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

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

@InProceedings{	  edwards.munro:abstracting,
  author	= {Helen M. Edwards and Malcolm Munro},
  title		= {Abstracting the Logical Processing Life Cycle for Entities
		  Using the RECAST method},
  pages		= {162--171},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1993},
  year		= {1993},
  publisher	= {IEEE Computer Society Press},
  month		= sep,
  abstract	= {The Reverse Engineering into CASE Technology method
		  (RECAST) takes the source code for an existing COBOL system
		  and derives a no-loss representation of the system
		  documented in a Structured System Analysis and Design
		  Method (SSADM) format. One key element of the method is the
		  abstraction of logical processing that affects the
		  individual entities of the system. For each entity this
		  processing is extracted from the physical implementation of
		  the system using a program slicing technique and is then
		  transformed into a logical representation (as an Entity
		  Life History) using a set of translation and transformation
		  rules. This paper describes how the abstraction is achieved
		  and illustrates it with an example that was derived from an
		  existing operational system that has been used as a case
		  study for the method.},
  class		= {Software_Reverse_Engineering, Reverse_Specification,
		  Model_Generating}
}

@InProceedings{	  edwards.munro:recast,
  author	= {H. M. Edwards and M. Munro},
  title		= {{RECAST}: reverse engineering from {COBOL} to {SSADM}
		  specification},
  pages		= {499--508},
  booktitle	= {Proceedings of the 15th  International Conference on
		  Software Engineering },
  year		= {1993},
  publisher	= {IEEE Computer Society Press},
  month		= apr,
  abstract	= {The Reverse Engineering into CASE Techology (RECAST) takes
		  the source code for an existing COBOL system and derives a
		  no-loss representation of the system documented in an
		  Structured Systems Analysis and Design Method (SSADM)
		  format. This representation of the system is derived
		  through the use of a series of transformations. This paper
		  describes the environment within which RECAST has been
		  developed, outlines the stages and steps of the RECAST
		  method and discusses the use of software support tools. An
		  overview is given of a case study that has been carried out
		  for a live system.},
  class		= {Software_Reverse_Engineering, Reverse_Specification, Model
		  Generating}
}

@InProceedings{	  edwards.munro:recast*1,
  author	= {H. Edwards and M. Munro},
  title		= {{RECAST}: reverse engineering from {COBOL} to {SSADM}
		  specifications},
  booktitle	= {Proceedings of the 1st  Working Conference on Reverse
		  Engineering },
  pages		= {44--53},
  year		= {1993},
  note		= { Describes methodology and tooling for the extraction of
		  SSADM diagrams from COBOL programs},
  class		= {Software_Reverse_Engineering, Reverse_Specification, Model
		  Generating}
}

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

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

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

@InProceedings{	  hildreth:reverse,
  author	= {Holly Hildreth},
  title		= {Reverse Engineering Requirements for Process-Control
		  Software},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1994},
  year		= {1994},
  pages		= {316-325},
  publisher	= {IEEE Computer Society Press},
  month		= sep,
  abstract	= {A method of reverse engineering requirements for
		  process-control system software is presented along with a
		  domain-specific functional structure. Techniques are
		  demonstrated on the executable pseudocode of a commercial
		  avionics control syhstem. Resulting requirements are
		  expressed as a state-based model of externally visible
		  behavior specified completely in the language of
		  process-control.},
  class		= {Software_Reverse_Engineering, Reverse_Specification,
		  Domain_Analysis}
}

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

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

@InProceedings{	  iscoe.williams.ea:domain,
  author	= {Neil Iscoe and Gerald B. Williams and Guillermo Arango},
  title		= {Domain Modeling for Software Engineering},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1991},
  year		= {1991},
  pages		= {340-343},
  organization	= {IEEE},
  publisher	= {IEEE Computer Society Press},
  abstract	= {Writing an application program requires an understanding
		  of both programming knowledge and application domain
		  knowledge. Programming knowledge is relatively well
		  understood. It is formal, modeled in a variety of ways,
		  explicit enough to be taught to novices, and general enough
		  to apply across many domains. Domain knowledge - although
		  it clearly exists in the minds of domain experts - it is
		  not so well understood. It is usually: 1) informal rather
		  than formal 2) implicit rather than explicit 3) ad hoc
		  instead of general purpose 4) modeled only incompletely and
		  indirectly in terms of problem-specific languages.},
  class		= {Software_Reverse_Engineering, Reverse_Specification,
		  Domain_Analysis}
}

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

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

@InProceedings{	  karakostas:use,
  author	= {V. Karakostas},
  title		= {The Use of Application Domain Knowledge for Effective
		  Software Maintenance},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1990},
  year		= {1990},
  pages		= {170-176},
  organization	= {IEEE},
  publisher	= {IEEE Computer Society Press},
  abstract	= {In a way similar to activities like specification and
		  design effective maintenance of software requires an
		  understanding of the application domain. Our approach is
		  based on the assumption that a model which links the
		  concepts of the application domain to their implementations
		  will assist in tracing the changing user requirements in
		  the software system and in identifying what is to be
		  changed and why, what needs to be carried out in order to
		  implement the change and how the existing system will be
		  affected as a result. This paper discusses the application
		  of the approach to the maintenance of an object-oriented
		  programming environment.},
  class		= {Software_Reverse_Engineering, Reverse_Specification,
		  Domain_Analysis}
}

@InProceedings{	  kozaczynski:catch-22,
  author	= {Wojtek Kozaczynski},
  title		= {The {'Catch 22'} of Reengineering},
  booktitle	= {Proceedings of the 12th  International Conference on
		  Software Engineering },
  pages		= {119},
  month		= mar,
  year		= {1990},
  abstract	= {In the software reengineering discussion it is assumed
		  that the system can be understood on the following four
		  levels: the programming language level, the control
		  structure level, the generic algorithm level, and the
		  problem domain level. It is noted that it is now possible
		  to build tools which understand systems on the first three
		  levels. There have been considerable advances in system
		  data analysis that will lead directly to identification of
		  abstract data types and objects. It is suggested that
		  future progress will critically depend on the ability to
		  represent and reason about the problem domain. The
		  reengineering systems of tomorrow will require knowledge
		  not only of software engineering, but more important, of
		  particular problem domains.},
  class		= {Software_Reverse_Engineering, Reverse_Specification,
		  Domain_Analysis}
}

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

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

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

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

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

@InProceedings{	  li.yang.ea:clarity,
  author	= {Yang Li and Hongji Yang and William Chu},
  title		= {Clarity Guided Belief Revision for Domain Knowledge
		  Recovery in Legacy Systems},
  booktitle	= {Proceedings of the 12th International Conference on
		  Software Engineering and Knowledge Engineering (SEKE2000)},
  publisher	= {Knowledge System Institute},
  year		= {2000},
  editor	= {Daniel E. Cooke and Joseph E. Urban},
  chapter	= {},
  pages		= {248-255},
  address	= {Chicago, USA},
  month		= {June},
  url		= {},
  abstract	= {Program understanding is the process of acquiring
		  knowledge from a computer program. Although research work
		  utilising knowledge engineering techniques has been
		  undertaken in this field, it is our observation that a
		  thorough application of AI methodology has not been
		  sufficiently explored. In this paper, we present a clarity
		  guided belief revision approach to domain knowledge
		  recovery in legacy software systems. Novel solutions are
		  given to three key AI issues in the context of domain
		  knowledge recovery from source code: knowledge
		  representation, where concrete semantic network is
		  separated from abstract semantic network to better
		  accommodate uncertainty reasoning and propagation;
		  uncertainty reasoning, which borrows ideas from
		  confirmation theory and recasts them in the context of
		  semantic network reasoning; heuristic search, which is
		  designed on the principle of programming psychology. Our
		  approach is light-weighted. It can be used stand-alone or
		  as a complement to traditional heavy-weighted domain
		  knowledge recovery methods. },
  keywords	= {program understanding, knowledge recovery, semantic
		  network, belief revision, heuristic search, programming
		  psychology},
  note		= {This paper describes our innovative work where
		  psychology-based methodology was brought into the area of
		  Articial Intelligence and was applied in the field of
		  domain knowledge recovery from source code.},
  class		= {Knowledge-Based_Concept_Assignment System_Modularizatio
		  Model_Generating Reverse_Specification Metrics
		  Reverse_Design Domain_Analysis
		  Metric-Based_Methods_in_Reverse_Design
		  Human_Oriented_Concept_Assignment_by_Informal_Reasoning
		  Software_Reverse_Engineering }
}

@Article{	  li.yang.ea:concept-oriented,
  author	= {Yang Li and Hongji Yang and William Chu},
  title		= {A Concept-Oriented Belief Revision Approach to Domain
		  Knowledge Recovery from Source Code},
  journal	= {Journal of Software Maintenance: Research and Practice},
  year		= {2000},
  volume	= {12},
  number	= {6},
  abstract	= {Domain knowledge is the soul of software systems. After
		  decades of software development, domain knowledge has
		  reached a certain degree of saturation. The recovery of
		  domain knowledge from source code is beneficial to many
		  software engineering activities, in particular, software
		  evolution. In the real world, the ambiguous appearance of
		  domain knowledge embedded in source code constitutes the
		  biggest barrier to recovering reliable domain knowledge. In
		  this paper, we introduce an innovative approach to
		  recovering domain knowledge with enhanced reliability from
		  source code. In particular, we divide domain knowledge into
		  inter-connected knowledge slices and match these knowledge
		  slices against the source code. Each knowledge slice has
		  its own authenticity evaluation function which takes the
		  belief of the evidences it needs as input and the
		  authenticity of the knowledge slice as output. Moreover,
		  the knowledge slices are arranged to exchange beliefs with
		  each other through inter-connections, i.e., concepts, so
		  that a better evaluation of the authenticity of these
		  knowledge slices can be obtained. The decision on
		  acknowledging recovered knowledge slices can therefore be
		  made more easily. Rooted in cognitive science and social
		  psychology, our approach is also widely applicable to other
		  knowledge recovery tasks. },
  keywords	= {domain knowledge recovery, uncertainty reasoning,
		  cooperative behaviour, semantic network},
  note		= {It is the first attempt of applying social psychology
		  theory to the field of knowledge recovery, in particular
		  design recovery.},
  class		= {Knowledge-Based_Concept_Assignment Using_graphs
		  Model_Generating Reverse_Specification
		  Cognitive_Processes_in_Human_Program_Understanding
		  Reverse_Design Domain_Analysis
		  Human_Oriented_Concept_Assignment_by_Informal_Reasonin
		  Intermediate_Representations_of_Source_Code
		  Software_Reverse_Engineering }
}

@InProceedings{	  li.yang.ea:towards,
  author	= {Yang Li and Hongji Yang and William Chu},
  title		= {Towards Building a Smarter Domain Knowledge Recovery
		  Assistant},
  booktitle	= {Proceedings of the 24th IEEE Annual Computer Software and
		  Applications Conference (COMPSAC2000)},
  publisher	= {IEEE Computer Society Press},
  year		= {2000},
  editor	= {},
  chapter	= {},
  pages		= {},
  address	= {},
  month		= {Oct},
  url		= {},
  abstract	= {Legacy systems need to be ``salvaged'' to prolong their
		  life circle. One way for such a salvation is to recover and
		  maintain domain knowledge embedded in legacy code. It is
		  our observation that existing methods or tools for domain
		  knowledge recovery from source code did not provide
		  maintainers with sufficient assistance to reduce the size
		  of analysable program sections, identify program sections
		  having intensive domain knowledge and maintain the belief
		  of a network of domain knowledge extracted from source code
		  which can accommodate change of belief coming from a user.
		  In this paper, we introduce techniques which can provide
		  software maintainers with smart assistance for the
		  above-mentioned three issues. },
  keywords	= {program partitioning, program readability metric, belief
		  network, domain knowledge recovery},
  note		= {We incorpate human psychology knowledge with the design of
		  a domain knowledge recovery tool.},
  class		= {Automated_Reverse_Design
		  Knowledge-Based_Concept_Assignment Reverse_Engineering_Tool
		  Model_Generating Reverse_Specification
		  Cognitive_Processes_in_Human_Program_Understanding Metrics
		  Reverse_Design System_Modularization Domain_Analysis
		  Recovery_of_Software_Architecture
		  Metric-Based_Methods_in_Reverse_Design
		  Human_Oriented_Concept_Assignment_by_Informal_Reasoning
		  Software_Reverse_Engineering }
}

@InProceedings{	  li.yang:fusing,
  author	= {Yang Li and Hongji Yang},
  title		= {Fusing Ambiguous Domain Knowledge Slices in a Reverse
		  Engineering Process},
  booktitle	= {Proceedings of the 7th Asia-Pacific Software Engineering
		  Conference (APSEC2000)},
  publisher	= {IEEE Computer Society Press},
  year		= {2000},
  editor	= {},
  chapter	= {},
  pages		= {},
  address	= {Singapore},
  month		= {Dec},
  url		= {},
  abstract	= {Recovering domain knowledge from legacy code plays an
		  important role in the new information technology era, which
		  can be of help for program understanding, system evolution
		  and software reuse. Traditional methods for domain
		  knowledge recovery from source code did not sufficiently
		  address the issue of ambiguity handling, in particular, the
		  propagation of ambiguity among multiple domain knowledge
		  slices recovered from source code in software reverse
		  engineering process. In this paper, we present a novel
		  approach to recovering unambiguous domain knowledge from
		  legacy code, where isolated ambiguous domain knowledge
		  slices are ``fused'' together in an iterative ambiguity
		  propagation process and hence the disambiguity of these
		  recovered knowledge slices is increased. },
  keywords	= {reverse engineering, domain knowledge recovery,
		  co-operative behaviour, belief revision},
  note		= {This is the first of this kind of work which deals with
		  the ambiguity involved in recovering large-scale domain
		  knowledge from source code.},
  class		= {Automated_Reverse_Design
		  Knowledge-Based_Concept_Assignment Using_graphs
		  Model_Generating Reverse_Specification
		  Cognitive_Processes_in_Human_Program_Understanding
		  Reverse_Design Domain_Analysis
		  Recovery_of_Software_Architectur
		  Metric-Based_Methods_in_Reverse_Design
		  Human_Oriented_Concept_Assignment_by_Informal_Reasoning
		  Intermediate_Representations_of_Source_Code
		  Software_Reverse_Engineering }
}

@InProceedings{	  liu.chen.ea:design,
  author	= {Xiaodong Liu and Zhiqiang Chen and Hongji Yang and Hussein
		  Zedan and William. C. Chu},
  title		= {A Design Framework for System Re-engineering},
  booktitle	= {Proceedings of Joint Asia Pacific Software Engineering
		  Conference and International Computer Science Conference},
  publisher	= {IEEE Computer Society},
  year		= {1997},
  address	= {Hong Kong},
  month		= {December},
  abstract	= { We discuss the current situation of formal methods and
		  their use in the re-engineering of computing systems,
		  especially real time systems. Based on the analysis result,
		  a solution which uses a consistent 4-sector Wide Spectrum
		  Language (WSL) is proposed, which presently includes the
		  general architecture and work flow, the structure of
		  Object-Action Model, the syntax and semantics of ObTAM
		  (Object Oriented Temporal Agent Model) and TGCL (Timed
		  Guarded Command Language). A small case study shows an
		  optimistic future of our WSL technique. Further research
		  will aim to build the complete semantic kernel of the WSL
		  and its associated algebraic laws, including transformation
		  rules and abstraction rules. },
  keywords	= {formal methods, re-engineering, wide spectrum language,
		  real-time systems, object orientation, Interval Temporal
		  Logic},
  class		= {Reengineering_in_General Requirement_Tracability
		  Software_Reverse_Engineering Reverse_Specification
		  Process_Models }
}

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

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

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

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

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

@InProceedings{	  nanduri.rugaber:requirements,
  author	= {Sastry Nanduri and Spencer Rugaber},
  title		= {Requirements Validation via Natural Language Parsing},
  booktitle	= {Proceedings of the 28th Hawaii International Conference on
		  System Sciences},
  address	= {Wailea, Maui, Hawaii},
  year		= {1995},
  month		= jan,
  abstract	= {Object Oriented Analysis (OOA) has become a popular method
		  for analyzing system requirements. Unfortunately however,
		  none of the current version of OOA have included a
		  validation technique tailored to the object oriented
		  approach. Most, instead, merely recommend document reviews
		  without specifying what kinds of problems to look for. This
		  paper explores the question by applying a natural language
		  parser to a requirement document, extracting candidate
		  objects, methods and associations, composing them into an
		  object model diagram, and then comparing the results to
		  those determined by manual OOA. To do this, we have adapted
		  an automated natural language parser and used it to examine
		  several high level specifications. The results indicate
		  that with a modest amount of effort, our technique can give
		  valuable feedback to the analyst.},
  ftp		= {ftp.cc.gatech.edu//pub/groups/reverse/repository/hicss.ps}
		  ,
  class		= {Software_Reverse_Engineering, Reverse_Specification,
		  Natural_Language_Processing_in_Reverse_Specification}
}

@Article{	  nanduri.rugaber:requirements*1,
  author	= {Sastry Nanduri and Spencer Rugaber},
  title		= {Requirements Validation via Automated Natural Language
		  Parsing},
  journal	= {Journal of MIS},
  year		= {1995},
  month		= jan,
  note		= {UpDated version of Nanduri:95a submitted for publication},
  abstract	= {Object Oriented Analysis (OOA) has become a popular method
		  for analyzing system requirements. Unfortunately however,
		  none of the current versions of OOA have included a
		  validation technique tailored to the object oriented
		  approach. Most, instead, merely recommend document reviews
		  without specifying what kinds of problems to look for. This
		  paper explores the question by applying a natural language
		  parser to a requirement document, extracting candidate
		  objects, methods and associations, composing them into an
		  object model diagram, and then comparing the results to
		  those determined by manual OOA. To do this, we have adapted
		  an automated natural language parser and used it to examine
		  several high level specifications. The results indicate
		  that with a modest amount of effort, our technique can give
		  valuable feedback to the analyst.},
  ftp		= {ftp.cc.gatech.edu//pub/groups/reverse/repository/jmis.ps},
  class		= {Software_Reverse_Engineering, Reverse_Specification,
		  Natural_Language_Processing_in_Reverse_Specification}
}

@InProceedings{	  ornburn.rugaber:reverse*1,
  author	= {Stephen B. Ornburn and Spencer Rugaber},
  title		= {Reverse Engineering: Resolving Conflicts between Expected
		  and Actual Software Design},
  pages		= {32-40},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1992},
  year		= {1992},
  publisher	= {IEEE Computer Society Press},
  month		= nov,
  abstract	= {A real-time embedded system was the subject of a series of
		  experiments in reverse engineering. These experiments
		  employed a method of reverse engineering, called
		  Synchronized Refinement, that analyzes a program,
		  describing its behaviour in the vocabulary of the
		  application domain and its structure in terms of design
		  decisions. The results provide insight into the role of
		  domain knowledge in this type of analysis together with the
		  tools used in the detailed analysis of code. The
		  experiments, which included the re-design of a component
		  and the diagnosis of a critical software failure, showed
		  how the real work of software maintenance is in resolving
		  apparent inconsistencies between the expectations that have
		  been derived from domain knowledge and the facts that have
		  been uncovered by applying reverse engineering tools to the
		  software.},
  class		= {Software_Reverse_Engineering, Reverse_Specification,
		  Domain_Analysis}
}

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

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

@Article{	  rugaber:position,
  author	= {Spencer Rugaber},
  title		= {Position Paper Domain Analysis and Reverse Engineering},
  journal	= {Software Engineering Techniques Workshop on Software
		  Reengineering},
  institution	= {Software Engineering Institute},
  address	= {Pittsburgh, Pennsysvania},
  year		= {1994},
  month		= may,
  abstract	= {This paper describes the reverse engineering problem. It
		  emphasizes the need for domain knowledge to fully
		  understand a given program. The terms domain, domain
		  analysis, domain representation, and the relationship to
		  reverse engineering are discussed. The issues of
		  methodolgy, representation, and tools are described.
		  Finally, some projects at Georgia's Institute of Technology
		  in the area of reverse engineering are presented.},
  ftp		= {ftp.cc.gatech.edu//pub/groups/reverse/repository/sei.ps},
  class		= {Software_Reverse_Engineering, Reverse_Specification,
		  Domain_Analysis}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@InProceedings{	  wilde.gomez.ea:locating,
  title		= {Locating user functionality in old code},
  author	= {N. Wilde and J. Gomez and T. Gust and D. Strasburg},
  pages		= {200--205},
  booktitle	= {\cite{SM92}},
  year		= {1992},
  note		= { Proposes a probabilistic technique to match expected
		  functionality with the actual functions as implemented in
		  existing code. An experiment reveals that the method works
		  reasonable but cannot replace human experts},
  class		= {Software_Reverse_Engineering, Reverse_Specification}
}

@InProceedings{	  wilde.gomez.ea:locating*1,
  author	= {Norman Wilde and Juan A. Gomez and Thomas Gust and Douglas
		  Strasburg},
  title		= {Locating User Functionality in Old Code},
  pages		= {200-205},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1992},
  year		= {1992},
  publisher	= {IEEE Computer Society Press},
  month		= nov,
  abstract	= {Software maintainers often have to recover requirements
		  traceability in old code. In other words, they need to
		  answer the question: 'In which parts of this program is
		  functionality X implemented?' This paper proposes a
		  methodology for answering this question based on the use of
		  carefully designed test cases as probes into the code.
		  While the methodology is not applicable to all kinds of
		  requirements and may not find all relevant code components,
		  it should often provide a maintainer with good starting
		  points for studying a large and poorly documented system.
		  Two formulations of the methodology are suggested and some
		  encouraging experimental results are presented from a case
		  study of a typical old program.},
  class		= {Software_Reverse_Engineering, Reverse_Specification,
		  Natural_Language_Processing_in_Reverse_Specification}
}

@InProceedings{	  yang.liu.ea:tackling,
  author	= {Hongji Yang and Xiaodong Liu and Hussein Zedan},
  title		= {Tackling the Abstraction Problem for Reverse Engineering
		  in a System Re-engineering Approach},
  booktitle	= {proceedings of the IEEE Conference on Software Maintenance
		  (ICSM'98)},
  publisher	= {IEEE Computer Society},
  year		= {1998},
  address	= {Washington D.C., USA},
  month		= {November},
  abstract	= {It is widely accepted that reverse engineering has three
		  components: restructuring, comprehension and production of
		  formal specification. In this paper, we advocate that the
		  three components could be achieved in a {\bf systematic}
		  approach by successfully applying a series of sound rules.
		  
		  The key approach to comprehension and the production of
		  formal specification is a notion of abstraction.
		  Abstraction is often interpreted as the act of hiding
		  irrelevant details. What constitute as relevant details is
		  often left open to different interpretations.
		  
		  A unified approach for reverse engineering is described
		  within which the notion of abstraction is classified and
		  precisely defined. Abstraction rules are given and applied
		  to various small examples. },
  keywords	= {reverse engineering, re-engineering, wide spectrum
		  language, abstraction, object oriented, Interval Temporal
		  Logic. },
  class		= {Reengineering_in_General Software_Reverse_Engineering
		  Reverse_Specification Formal_Methods Reverse_Design
		  Process_Models }
}

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