References of Fundamental_Methods_in_Reverse_Design

@Book{		  aho.sethi.ea:compilers,
  author	= { A.V. Aho and R. Sethi and J.D. Ullman },
  title		= { Compilers: Principles, Techniques, and Tools },
  publisher	= { Reading, Mass.: Addison-Wesley },
  year		= { 1985 },
  class		= {Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Static_Analysis }
}

@InProceedings{	  aiken.muntz.ea:framework,
  author	= {P. Aiken and A. Muntz and R. Richards},
  title		= {A framework for reverse engineering {D}o{D} legacy
		  information systems},
  booktitle	= {Proceedings of the 1st  Working Conference on Reverse
		  Engineering },
  pages		= {180--191},
  year		= {1993},
  note		= { Gives an overview of the reverse engineering methodology
		  used inside the DoD for the reengineering of information
		  systems},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design,
		  Data-Centered_Program_Understanding}
}

@Book{		  aiken:data,
  title		= {Data Reverse Engineering: Slaying the Legacy Dragon},
  author	= {P. Aiken},
  publisher	= {McGraw-Hill},
  year		= {1995},
  note		= { This is the first book describing the process of
		  recovering data architectures from existing information
		  systems and using it to develop a foundation for enterprise
		  integration and other reengineering efforts},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design,
		  Data-Centered_Program_Understanding}
}

@Article{	  al-zoubi.prakash:program,
  author	= {Al-Zoubi, R. and Prakash, A.},
  title		= {Program View Generation and Change Analysis Using
		  Attributed Dependency Graphs},
  journal	= {Journal of Software Maintenance: Research and Practice},
  volume	= {7},
  number	= {4},
  pages		= {239-262},
  month		= {July-August},
  year		= {1995},
  abstract	= {},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Code_Views,
		  Static_Analysis }
}

@TechReport{	  al-zoubi.prakash:software,
  author	= {Al-Zoubi, R. and Prakash, A.},
  title		= {Software Change Analysis via Attributed Dependency
		  Graphs},
  year		= {1991},
  month		= {May},
  number	= {CSE-TR-95-91},
  institution	= {Department of EECS, University of Michigan},
  class		= {Alteration, Change_Impact,Software_Reverse_Engineering,
		  Reverse_Design, Fundamental_Methods_in_Reverse_Design,
		  Static_Analysis }
}

@PhDThesis{	  al-zoubi:attributed,
  author	= {Ratib H. Al-Zoubi},
  title		= {Attributed Graph-Based Representations for Software View
		  Generation and Impact-of-Change Analysis},
  school	= {The University of Michigan},
  year		= {1992},
  abstract	= {Great ref. on change analysis; mostly PITS. Good related
		  work info. Tool is called SCAN.},
  class		= {Alteration, Change_Impact,Software_Reverse_Engineering,
		  Reverse_Design, Fundamental_Methods_in_Reverse_Design,
		  Software_Reverse_Engineering,
		  Intermediate_Representations_of_Source_Code, Using_graphs}
}

@InProceedings{	  anger.rodriguez.ea:combining,
  author	= {Frank D. Anger and Rita V. Rodriguez and Michal Young},
  title		= {Combining Static and Dynamic Analysis of Concurrent
		  Programs},
  pages		= {89-98},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1994},
  year		= {1994},
  publisher	= {IEEE Computer Society Press},
  month		= sep,
  abstract	= {Concurrent systems are inherently more difficult to
		  analyze and visualize than sequential programs. The
		  difficulty of producing correct concurrent programs is
		  mirrored in maintenance as difficulty in extracting a
		  correct high-level model of task interactions and
		  predicting the effect of a modification to portions of a
		  system. The authors advocate a methodology that combines
		  static analysis of an abstract model with dynamic analysis
		  of source code. While the abstract model is amenable to
		  exhaustive analysis, dynamic analysis is capable checking
		  richer classes of specifications, and moreover provides a
		  check on the correctness of simplifications and assumptions
		  inherent in abstract models. We illustrate this approach by
		  combining two tools, the PAL system for compositional
		  reachability analysis and the FORESEE analysis tool for
		  temporal analysis of runtime traces, applied to a
		  simulation scenario.},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Dynamic_Analysis,
		  Dynamic_Data_Flow_Analysis }
}

@InProceedings{	  anger.rodriguez.ea:combining*1,
  author	= { F.D. Anger and R.V. Rodriguez and M. Young },
  title		= { Combining Static and Dynamic Analysis of Concurrent
		  Programs },
  booktitle	= { Proceedings of the International Conference on Software
		  Maintenance (ICSM~'94), {\rm (Victoria, B.C.; Sept. 19-23,
		  1994)}},
  year		= { September 1994 },
  editor	= { Hausi A. M\"{u}ller and Mari Georges },
  pages		= { 89-98 },
  abstract	= { },
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Static_Analysis,
		  Dynamic_Analysis},
  keywords	= {concurrency, parallelism, dynamic analysis, static
		  analysis}
}

@Unpublished{	  antoniol.fiutem.ea:program,
  author	= {G. Antoniol and R. Fiutem and G. Lutteri and P. Tonella
		  and S. Zanfei},
  title		= {Program Understanding and Maintenance with the CANTO
		  environment},
  year		= {1998},
  class		= {Software_Reverse_Engineering,
		  Intermediate_Representations_of_Source_Code, Using_graphs,
		  Fundamental_Methods_in_Reverse_Design, Static_Analysis,
		  Static_Data_Flow_Analysis,
		  Recovery_of_Software_Architecture}
}

@InProceedings{	  baecker:enhancing,
  author	= {R. Baecker},
  year		= {April 1988},
  pages		= {356-366},
  title		= {Enhancing Program Readability and Comprehensibility with
		  Tools for Program Visualization},
  booktitle	= {Proceedings of the 10th International Conference on
		  Software Engineering},
  abstract	= {},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Code_Views }
}

@InProceedings{	  bailes.burnim.ea:derivation,
  author	= {P.A. Bailes and P. Burnim and M. Chapman and D. Johnston},
  title		= {Derivation and presentation of an Abstract Program Space
		  for ADA},
  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_Design,
		  Fundamental_Methods_in_Reverse_Design, Code_Views}
}

@InProceedings{	  baker.eick:visualizing*1,
  author	= { M.J. Baker and S.G. Eick },
  title		= { Visualizing Software Systems },
  booktitle	= { Proceedings of the 16th International Conference on
		  Software Engineering {\rm (Sorrento, Italy; May 16-21,
		  1994)} },
  publisher	= { IEEE Computer Society Press },
  year		= { 1994 },
  pages		= { 59-67 },
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Code_Views}
}

@Article{	  baratta-perez.conn.ea:ada,
  author	= {Grace {Baratta-Perez} and Richard L. Conn and Charles A.
		  Finnell and Thomas J. Walsh},
  title		= {Ada System Dependency Analyzer Tool},
  journal	= {Computer},
  month		= {February},
  year		= {1994},
  volume	= {27},
  number	= {2},
  pages		= {49-55},
  abstract	= { Describes the Ada SDA: a simple tool that parses Ada into
		  an OO-AST and does simple analysis. Focus in on two areas:
		  portability checks (e.g., what pragma are used, when
		  non-Ada routines are called, such as X/Motif), and
		  "architectural" analysis: what subunits and packages are
		  used, what is the compilation dependency order, etc. Fairly
		  pedestrian analysis. . The ability to imbed diverse systems
		  within an application, particularly COTS software, often
		  adds to architectural complexity. This becomes more
		  apparent when software must be ported. It is then that the
		  full consequences of unweildly software architecture are
		  realized. . A major thrust of modern SE mthods, languages,
		  and tools is to promote software visibility and to present
		  information about the underlying software architecture.
		  Architecture determines whether a system can evolve, be
		  enhanced, or be reused in a cost-effective way. . With
		  large, complex software systems, automated tools are
		  indispensible for identifying the architectural components,
		  the structure that connects them, and other subtle
		  dependencies. (This is Re-DITL, my work.) . The Ada SDA is
		  a "software architecture analysis tool" (nice term to use).
		  . The SDA tool identifies Ada source code dependencies on
		  COTS products such as operating systems, compilers, the X
		  Window System, and routines written in other languages, and
		  can thus predict software portability and reliability. . (I
		  could do similar "name filtering" using scripts in Rigi.) .
		  The SDA merges two key tecknologies: compiler construction
		  and OOA, OOD, and OO-implementation. . They use ayacc and
		  aflex, Ada parsers and scanners resp. from UC Irvine's
		  Arcadia project. (NB: These are PD tools; snarf!) . They
		  allow the user to specify what they want extracted from the
		  Ada source code (extraction flexibility!) via command-line
		  options. . Identifying source code dependencies: . Bit of a
		  misonomer. . Identify potential portability stumbling
		  blocks. . A "taxonomy" of "portability errors/rules" are
		  codified; they filter the source looking for instances of
		  rule violations. (Similar to Joel's DF/FQ; I could do it
		  using scripts => App area) . Ada predefined types . Ada
		  representation clauses . Interfaces to non-Ada routines .
		  Pragmas . Unidentified withed units . Machine code
		  statements . X Windows and Motif interfaces .
		  ("Portability" is a good example of an application of
		  scripting) . Analyzing Ada source code architecture .
		  Again, a bit of a misnomer (only more so this time) . File
		  statistics (number of files, library unites, comments, ...)
		  . Subunits . Library units and dependencies . Compilation
		  order . Exceptions . Reports are vt100-style tabular
		  format. Not much tweaking by the users on report format or
		  content. . "The Ada SDA provides visibility into the
		  architecture of software systems and an indication of the
		  software's portability and reliability." . This tool may
		  become PD in the future. },
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Static_Analysis }
}

@InProceedings{	  beck.eichmann:program,
  author	= {J. Beck and D. Eichmann},
  title		= {Program and interface slicing for reverse engineering},
  pages		= {509--519},
  booktitle	= {Proceedings of the 15th  International Conference on
		  Software Engineering },
  year		= {1993},
  publisher	= {IEEE Computer Society Press},
  month		= apr,
  abstract	= {Reverse engineering involves a great deal of effort in
		  comprehension of the current implementation of a software
		  system and the ways in which it differs from the original
		  design. Automated support tools are critical to the success
		  of such efforts. Wh show how program slicing techniques can
		  be employed to assist in the comprehension of large
		  software systems, through traditional slicing techniques at
		  the statement level, and through a new technique, interface
		  slicing, at the module level.},
  note		= {Describes the use of program slicing for the reverse
		  engineering of Ada packages},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Static_Analysis,
		  Static_Data_Flow_Analysis, Program_Slicing}
}

@InProceedings{	  beck.eichmann:program*1,
  author	= { J. Beck and D. Eichmann },
  title		= { Program and Interface Slicing for Reverse Engineering },
  booktitle	= { WCRE~'93: Proceedings of the 1993 Working Conference on
		  Reverse Engineering, {\rm (Baltimore, Maryland; May 21-23,
		  1993)}},
  year		= { May 1993 },
  pages		= { 54-63 },
  publisher	= { IEEE Computer Society Press (Order Number 3780-02) },
  abstract	= { },
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Program_Slicing }
}

@InProceedings{	  benedusi.benvenuto.ea:role,
  author	= {Benedusi, P. and Benvenuto, V. and Tomacelli, L.},
  title		= {The Role of Testing and Dynamic Analysis in Program
		  Comprehension Supports},
  editor	= {Fadini, Bruno and Rajlich, Vaclav},
  booktitle	= {Proceedings of the IEEE Second Workshop on Program
		  Comprehension},
  year		= {1993},
  month		= {July},
  pages		= {149-158},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Dynamic_Analysis,
		  Alteration, Change_Test }
}

@TechReport{	  biggerstaff:hypermedia,
  author	= {Ted J. Biggerstaff},
  title		= {Hypermedia as a Tool to Aid Large Scale reuse},
  institution	= {MCC},
  year		= {1987},
  type		= {Technical Report},
  number	= {STP-202-87},
  month		= jul,
  abstract	= {This paper argues that the largest payoff of reuse is in
		  the reuse of large scale components. In order to make such
		  reuse feasible, the component to be reused must be
		  accompanied by a model that aids the software engineering
		  in understanding the component to be reused. We illustrate
		  the use of a hypermedia tool in developing such a model and
		  present what we have discovered in the course of building
		  an example of such a model.},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Hypertext}
}

@Article{	  binkley:application,
  author	= {David Binkley},
  title		= {The Application of Program Slicing to Regression Testing},
  journal	= {Information and Software Technology},
  year		= {1998},
  key		= {Program Slicing},
  volume	= {40},
  number	= {11-12},
  pages		= {583-594},
  month		= {November},
  note		= {Special issue on program slicing},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Program_Slicing}
}

@InProceedings{	  binkley:using,
  title		= {Using semantic differencing to reduce the cost of
		  regression testing},
  author	= {D. Binkley},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1992},
  pages		= {41--50},
  year		= {1992},
  note		= { Gives an algorithm using dependence graphs and program
		  slicing to partition a modified program in parts with
		  affected program behaviour and parts with unaffected
		  behaviour. Only the parts with affected behaviour have to
		  be re-tested},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Program_Slicing}
}

@Book{		  blaha.premerlani:object-oriented,
  author	= {michael blaha and william premerlani},
  title		= {Object-Oriented Modeling and Design for Database
		  Applications},
  publisher	= {Prentice Hall},
  year		= {1998},
  abstract	= {Chapter 20 is about reverse engineering of databases.},
  keywords	= {UML, model, database, reverse engineering},
  note		= {Chapter 20 of the book provides a simple process for
		  reverse engineering of hierarchical, network, and
		  relational databases.},
  class		= {Software_Reverse_Engineering
		  Data-Centered_Program_Understanding Reverse_Design
		  Fundamental_Methods_in_Reverse_Design }
}

@InProceedings{	  blazy.facon:interprocedural,
  author	= {Sandrine Blazy and Philippe Facon},
  title		= {Interprocedural analysis for program comprehension by
		  specialization},
  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_Design,
		  Fundamental_Methods_in_Reverse_Design, Static_Analysis }
}

@InProceedings{	  browne.johnson:fast,
  author	= {Browne, J.C. and Johnson, D.B.},
  title		= {{FAST}: A Second Generation Program Analysis System},
  booktitle	= {ICSE'3: Proceedings of the 3rd International Conference on
		  Software Engineering, {\rm (Atlanta, Georgia; May 10-12,
		  1978)}},
  year		= {May 1978},
  pages		= {142-148},
  abstract	= {},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Static_Analysis }
}

@Article{	  canfora.cimitile.ea:conditioned,
  author	= {Gerardo Canfora and Aniello Cimitile and Andrea De Lucia},
  title		= {Conditioned Program Slicing},
  journal	= {Information and Software Technology},
  year		= {1998},
  key		= {Program Slicing},
  volume	= {40},
  number	= {11-12},
  pages		= {595-608},
  month		= {November},
  note		= {Special issue on program slicing},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Program_Slicing}
}

@Article{	  canfora.cimitile.ea:logic-based,
  key		= {Canfora et al.},
  author	= {G. Canfora and Aniello Cimitile and G. de Carlini},
  title		= {A Logic-Based Approach to Reverse Engineering Tools
		  Production},
  year		= {1992},
  journal	= {IEEE Transactions on Software Engineering},
  pages		= {1053--1064},
  volume	= {18},
  number	= {12},
  month		= dec,
  abstract	= {This paper analyzes difficulties arising in the use of
		  documents produces by Reverse Engineering tools. With
		  reference to inter-modula data flow analysis for Pascal
		  software systems, an interactive and evolutionary is
		  proposed. The tool is based on: i) the production of
		  inter-modular data flow information by static analysis of
		  code; ii) its representaton in a Prolog program dictionary;
		  iii) a Prolog abstractor that allows the specific queries
		  to be answered.},
  location	= {CMU E \&{} S Library},
  class		= {Software_Reverse_Engineering,
		  Intermediate_Representations_of_Source_Code,
		  Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Static_Analysis,
		  Static_Data_Flow_Analysis}
}

@InProceedings{	  canfora.cimitile.ea:petri,
  author	= {G. Canfora and Aniello Cimitile and De Carlini, Ugo},
  title		= {Petri Nets and Reverse Engineering in Concurrent
		  Environments},
  booktitle	= {Proceedings of the 3rd International Conference on
		  Software Engineering and Knowledge Engineering SEKE' 91},
  year		= {1991},
  pages		= {213-223},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Code_Views}
}

@Article{	  canfora.cimitile.ea:reverse*2,
  title		= {A Reverse Engineering Process for Design Level Document
		  Production from ADA Code},
  author	= {G. Canfora and A. Cimitile and U. De Carlini},
  journal	= {Information and Software Technology},
  volume	= {35},
  number	= {1},
  pages		= {23--34},
  year		= {1993},
  note		= { A reverse engineering process for producing design level
		  documents by static analysis of ADA code is described. This
		  is achieved via concurrent data flow diagrams describing
		  the task structure and the data flow between tasks.},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Static_Analysis,
		  Process_Models_for_Reverse_Design}
}

@Article{	  chen.nishimoto.ea:c,
  author	= {Y-F. Chen and M.Y. Nishimoto and C.V. Ramamoorthy},
  title		= {The {C} Information Abstraction System},
  journal	= {IEEE Transactions on Software Engineering},
  volume	= {16},
  number	= {3},
  pages		= {325-334},
  year		= {1990},
  note		= { A system for analyzing program structures is described.
		  The applications of this system include: generation of
		  graphical views, subsystem extraction, program layering,
		  dead code elimination, and binding analysis},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Static_Analysis}
}

@InProceedings{	  cheung.kramer:integrated,
  author	= {S. C. Cheung and J. Kramer},
  title		= {An integrated method for effective behaviour analysis of
		  distributed systems},
  pages		= {309--322},
  booktitle	= {Proceedings of the 16th  International Conference on
		  Software Engineering },
  year		= {1994},
  publisher	= {IEEE Computer Society Press},
  month		= may,
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Static_Analysis,
		  Static_Data_Flow_Analysis}
}

@Article{	  cordy.eliot.ea:turingtool,
  author	= {J.R. Cordy and N.L. Eliot and M.G. Robertson},
  title		= {TuringTool: A User Interface to Aid in the Software
		  Maintenance Task},
  journal	= {IEEE Transactions on Software Engineering},
  volume	= {16},
  number	= {3},
  pages		= {294-301},
  year		= {1990},
  note		= { In this paper the approach of viewing a program in a
		  structured way is advocated. With the aid of queries the
		  user can influence the view of the program and can,
		  therefore, get a better idea of what the program is doing.
		  Things that are not important for a certain view are
		  elided, but can be accessed by clicking on them---the
		  elided text becomes visual. The program can also be edited
		  with this tool},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Code_Views}
}

@InProceedings{	  cowan.german.ea:enhancing,
  key		= {Cowan et. al, 1994},
  author	= {D.D. Cowan and D.M. Germ\'an and C.J.P. Lucena and A. von
		  Staa},
  title		= {Enhancing Code for Readability and Comprehension Using
		  SGML},
  pages		= {181-190},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1994},
  year		= {1994},
  publisher	= {IEEE Computer Society Press},
  month		= sep,
  abstract	= {Reading and understanding programs is a key activity in
		  software reengineering, development, and maintenance. The
		  ability of people to understand programs is directly
		  related to the ease with which the source code and
		  documentation can be read. Thus, enhancements to the style
		  of presentation should heighten this comprehensibility. The
		  authors describe methods that use markup laguages such as
		  SGML to embed information about the syntax and semantics of
		  a program in the program code, and then show how these can
		  be used to enhance its presentation style. The authors also
		  briefly discuss the extension of these markup language
		  concepts to text databases, and indicate how they can
		  support various structural views of the code through
		  browsing techniques associcated with database queries.},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design,
		  Reformatting_and_Markup_Languages}
}

@InProceedings{	  cross:reverse,
  author	= {J. Cross},
  title		= {Reverse engineering of control structure diagrams},
  booktitle	= {Proceedings of the 1st  Working Conference on Reverse
		  Engineering },
  pages		= {107--116},
  year		= {1993},
  note		= { Describes a tool for the automatic generation of a new
		  graphical representation for Ada software (Control
		  Structure Diagrams). These diagrams aim at improving the
		  comprehension of Ada programs and can potentially replace
		  the original source code},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Static_Analysis,
		  Code_Views}
}

@InProceedings{	  cutillo.fiore.ea:identification,
  author	= {F. Cutillo and P. Fiore and G. Visaggio},
  title		= {Identification and extraction of ``domain independent''
		  components in large programs},
  booktitle	= {Proceedings of the 1st  Working Conference on Reverse
		  Engineering },
  pages		= {83--92},
  year		= {1993},
  note		= { Uses program slicing to extract components from COBOL
		  programs by means of Viasoft's tools INSIGHT, SMARTDOC and
		  RENAISSANCE},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Program_Slicing}
}

@Article{	  cytron.ferrante.ea:efficiently,
  author	= {Ron Cytron and Jeanne Ferrante and Barry K. Rosen and Mark
		  N. Wegman and F. Kenneth Zadeck},
  title		= {Efficiently Computing Static Single Assignment Form and
		  the Control Dependence Graph},
  journal	= {ACS Transaction on Programming Languages and Systems},
  year		= {1991},
  volume	= {13},
  number	= {4},
  pages		= {451-490},
  month		= {October},
  abstract	= {In optimizing compilers, data structure choices directly
		  influence the power and efficiency of practical program
		  optimization. A poor choice of data structure can inhibit
		  optimization or slow compilation to the point that advanced
		  optimization features become undesirable. Recently, static
		  single assignment form and the control dependence graph
		  have been proposed to represent data flow and control flow
		  propertiee of programs. Each of these previously unrelated
		  techniques lends efficiency and power to a useful class of
		  program optimization. Although both of these structures are
		  attractive, the difficulty of their construction and their
		  potential size have discouraged their use. We present new
		  algorithms that efficiently compute these data structures
		  for arbitrary control flow graphs. The algorithms use
		  dominance frontiers, a new concept that may have other
		  applications. We also give analytical and experimental
		  evidence that all of these data structures are usually
		  linear in the size of the original program. This paper thus
		  presents strong evidence that these structures can be of
		  practical use in optimization.},
  keywords	= {algorithms languages control dependence control flow graph
		  def-use chain dominator optimizing compilers ssa},
  class		= {Software_Reverse_Engineering Static_Data_Flow_Analysis
		  Reverse_Design Static_Control_Flow_Analysis
		  Fundamental_Methods_in_Reverse_Design Static_Analysis }
}

@Article{	  devanbu.bachman.ea:lassie,
  author	= {P. Devanbu and R.J. Bachman and P.G. Selfridge and B.W.
		  Ballard},
  title		= {La{SSIE}: A knowledge-based software information system},
  journal	= {Communications of the ACM},
  volume	= {34},
  number	= {5},
  pages		= {35-49},
  year		= {1991},
  note		= { A system called LaSSIE (Large Software System Information
		  Environment) is presented. It incorporates a large
		  knowledge base, a semantic retrieval algorithm based on
		  formal inference, and a powerful user interface
		  incorporating a graphical browser and a natural language
		  parser. The system is intended to help programmers find
		  useful information about large software systems},
  class		= {Software_Reverse_Engineering,
		  Software_Reverse_Engineering_Tools, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Static_Analysis}
}

@InProceedings{	  devanbu.brachman.ea:lassie,
  author	= {P. Devanbu and R. J. Brachman and P. G. Selfridge and B.
		  W. Ballard},
  title		= {{LaSSIE}: A Knowledge-based Software Information System},
  booktitle	= {Proceedings of the 12th  International Conference on
		  Software Engineering },
  pages		= {249--261},
  month		= mar,
  year		= {1990},
  abstract	= {The authors discuss the important problem of invisibility
		  that is inherent in the task of developing large software
		  systems. It is pointed out that there are no direct
		  solutions to this problem; however, there are several
		  categories of systems-relational code analyzers, reuse
		  librarians, and project management databases-that can be
		  seen as addressing aspects of the invisibility problem. It
		  is argued that these systems do not adequately deal with
		  certain important aspects of the problem of
		  invisibility-semantic proliferation, multiple views, and
		  the need for intelligent indexing. A system called LaSSIE,
		  which uses knowledge representation and reasoning
		  technology to address each of these three issues directly
		  and thereby help with the invisibility problem, has been
		  built. The authors conclude with an evaluation of the
		  system and a discussion of open problems and ongoing
		  work.},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Code_Views,
		  Knowledge-Based_Concept_Assignment}
}

@Article{	  devanbu.rosenblum.ea:generating,
  key		= {DRW96},
  author	= {P.T. Devanbu and D.R. Rosenblum and A.L. Wolf},
  title		= {Generating Testing and Analysis Tools},
  journal	= {ACM Transactions on Software Engineering and Methodology},
  year		= {1996},
  volume	= {5},
  number	= {1},
  pages		= {42-62},
  note		= {This article describes tools for analysing C/C++ programs
		  for programming understanding. These tools are generated
		  and support a procedural mechanism to retrieve information
		  from the C/C++ programs.},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design,
		  Source_Code_Queries}
}

@InProceedings{	  devanbu:genoa,
  author	= {P. T. Devanbu},
  title		= {{GENOA} - {A} Customizable, language- and Front-end
		  Independent Code Analyzer},
  booktitle	= {Proceedings of the 14th  International Conference on
		  Software Engineering },
  pages		= {307--317},
  month		= may,
  year		= {1992},
  abstract	= {Programmers working on large software systems spend a
		  great deal of time examining code and trying to understand
		  it. Code analysis tools (e.g. cross referencing tools such
		  as CIA and Cscope) can be very helpful in this process.
		  This paper describes GENOA, an application generator that
		  can produce a whole range of useful code analysis tools.
		  GENOA is designed to be language- and front-end
		  independent; it can be interfaced to any front-end for any
		  language that produces an attributed parse tree, simply by
		  writing an interface specification. While GENOA programs
		  can perform arbitrary analyses on the parse tree, the GENOA
		  language has special, compact iteration operators that are
		  tuned for expressing simple, polynomial time analysis
		  programs. It describes the system, provides several
		  practical examples, and presents complexity and
		  expressivity results for the above-mentioned sublanguage of
		  GENOA.},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Static_Analysis,
		  Static_Data_Flow_Analysis}
}

@Article{	  field.tip:dynamic,
  author	= {John Field and Frank Tip},
  title		= {Dynamic Dependence in Term Rewriting Systems and its
		  Application to Program Slicing},
  journal	= {Information and Software Technology},
  year		= {1998},
  key		= {Program Slicing},
  volume	= {40},
  number	= {11-12},
  pages		= {609-634},
  month		= {November},
  note		= {Special issue on program slicing},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Program_Slicing}
}

@InProceedings{	  fletton.munro:redocumenting,
  author	= {N. T. Fletton and M. Munro},
  title		= {Redocumenting Software Systems Using Hypertext
		  Technology},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1988},
  year		= {1988},
  pages		= {54-59},
  organization	= {IEEE},
  publisher	= {IEEE Computer Society Press},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Hypertext}
}

@Article{	  forgacs:double,
  key		= {Forgacs, 1994},
  author	= {Istv\'an Forg\'acs},
  title		= {Double Iterative Framework for Flow-Sensitive
		  Interprocedural Data Flow Analysis},
  journal	= { ACM  Transactions on Software Engineering and
		  Methodology},
  year		= {1994},
  volume	= {3},
  number	= {1},
  pages		= {29-55},
  month		= jan,
  abstract	= {Compiler optimization, parallel processing, data flow
		  testing, and symbolic debugging can benefit from
		  interprocedural data flow analysis. However, the live,
		  reaching definition, and most summary data flow problems
		  are theoretically intractable in the interprocedural case.
		  A method is presented that reduces the exponential time
		  bound with the help of an algorithm that solves the problem
		  in polynomial time. Either the resulting sets contain
		  precise results or the missing (or additional) results do
		  not cause any problems during their use. The authors also
		  introduce the double iterative framework, where one
		  procedure is processed at a time. The results of the
		  intraprocedural analysis of procedures the propagates along
		  the edges of the call multi-graph. In this way the intra
		  and interprocedural analyses are executed alternately until
		  there is no change in any result set. This method can be
		  applied to any known interprocedural data flow problem.
		  Here the algorithms for the kill, live variables, and
		  reaching definitions problems are presented. Besides for
		  precision, the algorithms can be used for very large
		  programs, and since inter and intraprocedural analyses can
		  be optimized separately, the method is fast as well.},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Static_Analysis,
		  Static_Data_Flow_Analysis}
}

@InProceedings{	  friedrich.witschurke:fapu,
  author	= {Horst Friedrich and Reiner Witschurke},
  title		= {The FAPU Workbench},
  booktitle	= {1st  European Conference on Software Maintenance and
		  Reengineering 97},
  month		= mar,
  year		= {1997},
  publisher	= {IEEE Computer Society Press},
  abstract	= {Before software can be adapted to changing economical,
		  organizational and technical conditions, it has to be
		  ABunderstoodBB. Understanding involves obtaining all the
		  information belonging to the application system in question
		  by means of analysis, interpretation and evaluation of the
		  software's structures (the individual programs of the
		  various program systems plus existing documentation) and of
		  the context and exact nature of its use (e.g. business
		  processes and workflows). Within a program of research into
		  tools supporting application understanding, the Fraunhofer
		  ISST has developed a prototype of the FAPU Workbench (FAPU
		  - FORTRAN Application and Program Understanding). A special
		  feature of FAPU is that it distinguishes between program
		  information and non-program information and enables
		  interactive linking within and between these two types of
		  information. FAPU can handle files consisting of a mixture
		  of programs in different languages, control commands and
		  data. Its robust parser can analyse a wide range of FORTRAN
		  dialects and deal with unknown constructs. The location of
		  comments within source code is preserved, new comments can
		  be added and existing ones modified. The analysis is always
		  performed with respect to a platform model containing
		  information about the computer type, the operating system,
		  and the compiler. As well as many analysis options and the
		  synchronization of their presentation, FAPU also enables
		  visualization of COMMON blocks. This paper presents the
		  tool developed at the Fraunhofer ISST. },
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Static_Analysis}
}

@InProceedings{	  g-snelting.tip:reengineering,
  author	= {G. Snelting, and F. Tip},
  title		= {Reengineering Class Hierarchies using Concept Analysis},
  booktitle	= {Proc. SIGSOFT Symposium on Foundations of Software
		  Engineering},
  publisher	= {ACM},
  year		= {1998},
  key		= {Concept Analysis},
  class		= {Inhertiance_Hierarchies_Restructuring
		  Software_Reverse_Engineering Static_Data_Flow_Analysis
		  Reverse_Design Re-Design Static_Control_Flow_Analysis
		  Fundamental_Methods_in_Reverse_Design Alteration
		  Static_Analysis }
}

@Article{	  gallagher.lyle:using,
  author	= {Keith Brian Gallagher and James R. Lyle},
  title		= {Using Program Slicing in Software Maintenance},
  journal	= {IEEE Transactions on Software Engineering},
  year		= {1991},
  volume	= {17},
  number	= {8},
  pages		= {751-761},
  month		= aug,
  abstract	= {Program slicing, introduces by Weiser, is known to help
		  programmers in understanding foreign code and in debugging.
		  We apply program slicing to the maintenance problem by
		  extending the notion of a program slice (that orginally
		  required both a variable and line number) to a
		  decomposition slice, one that captures all computation on a
		  given variable; i.e., is independent of line numbers. Using
		  the lattice of single variable decomposition slices ordered
		  by set inclusion, we demonstrate how to form a slice-based
		  decomposition for programs. We are then able to delineate
		  the effects of a proposed change by isolating those effects
		  in a single component of the decomposition. This gives
		  maintainers a straightforward technique for determining
		  those statements and variables which may be modified in a
		  component and those which may not. Using the decomposition,
		  we provide a set of principles to prohibit changes which
		  will interfere with unmodified components. These
		  semantically consistent changes can then be merged back
		  into the original program in linear time. Moreover, the
		  maintainer can test the changes in the component with the
		  assurance that there are no linkages into other components.
		  Thus decomposition slicing induces a new software
		  maintenance process model which eliminates the need for
		  regression testing.},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Static_Analysis,
		  Static_Data_Flow_Analysis, Program_Slicing}
}

@Article{	  gallagher.lyle:using*1,
  title		= {Using program slicing in software maintenance},
  author	= {K. Gallagher and J. Lyle},
  journal	= {IEEE Transactions on Software Engineering},
  volume	= {17},
  number	= {8},
  pages		= {751--761},
  year		= {1991},
  note		= { In this paper the technique of program slicing is used to
		  facilitate maintenance of software systems by extending the
		  notion of program slice to a so-called decomposition slice
		  (a slice that captures all computation on a given
		  variable)},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Program_Slicing}
}

@InProceedings{	  gillis.wright:improving,
  author	= {Keith D. Gillis and David G. Wright},
  title		= {Improving Software Maintenance Using System-Level Reverse
		  Engineering},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1990},
  year		= {1990},
  pages		= {84-90},
  organization	= {IEEE},
  publisher	= {IEEE Computer Society Press},
  abstract	= {Success in the software maintenance environment depends
		  upon the ability to read and comprehend existing source
		  code. A high level of comprehension is becoming more and
		  more more difficult to achieve as systems increase in
		  overall size and complexity. The described Fortran Reverse
		  Engineering software package programmatically analyzes
		  existing Fortran source code and generates complete
		  Structure Charts, and Module Specifications in a CASE
		  environment. The user can also select options to create
		  software trees and a variety of cross reference-tables. The
		  use of these objects can increase programmer productivity
		  by providing system-level details in a manner that can be
		  easily understood. They also aid in the software
		  maintenance process by providing the design baseline for
		  future software modifications and adds documentation of the
		  software set. Integrating a system-level reverse
		  engineering utility tool into a CASE enfivonment is just
		  one step toward improving programmer productivity and
		  increasing success in the software maintenance process.},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Code_Views}
}

@InProceedings{	  gopal.schach:using,
  author	= {Rajeev Gopal and Stephan R. Schach},
  title		= {Using Automatic Program Decomposition Techniques in
		  Software Maintenance Tools},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1989},
  year		= {1989},
  pages		= {132-141},
  organization	= {IEEE},
  publisher	= {IEEE Computer Society Press},
  abstract	= {Program decomposition can assist maintenance programmers
		  in all three phses of maintenance, namely comprehension,
		  modification and debugging. Visibility flow graphs are
		  introduced to represent the information about the static
		  semantics of a program. Using static analysis of programs,
		  it is possible to approximate their dynamic behaviour. More
		  precise analysis is possible if the program is monitored
		  during its execution. For dynamic semantics, dependence
		  relations are used that reflect the dependency of
		  statements on the input value of variables and of the
		  output value of variables on the statements. These
		  relations are generated both at static analysis time, and
		  also during program execution. Some sample sessions with a
		  prototype program analyzer for a subset of Ada are also
		  included.},
  class		= {Software_Reverse_Engineering,
		  Intermediate_Representations_of_Source_Code, Using_graphs,
		  Reverse_Design, Fundamental_Methods_in_Reverse_Design,
		  Static_Analysis, Static_Data_Flow_Analysis,
		  Dyanmic_Analysis, Dynamic_Data_Flow_Analysis}
}

@InProceedings{	  gupta.harrold.ea:approach,
  title		= {An approach to regression testing using slicing},
  author	= {R. Gupta and M. Harrold and M. Soffa},
  pages		= {299--308},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1992},
  year		= {1992},
  note		= { A new approach to data flow based regression testing is
		  described that uses program slicing algorithms to detect
		  definition-use pairs that are affected by a program change.
		  The advantage of this approach is that neither the data
		  flow history nor a recomputation of data flow is
		  necessary},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Program_Slicing}
}

@InProceedings{	  hainaut.chandelon.ea:contribution,
  author	= {J.-L. Hainaut and M. Chandelon and C. Tonneau and M.
		  Joris},
  title		= {Contribution to a theory of database reverse engineering},
  booktitle	= {Proceedings of the 1st  Working Conference on Reverse
		  Engineering },
  pages		= {161--170},
  year		= {1993},
  note		= {Gives a methodology for recovering the conceptual schema
		  of databases. Illustrated with various COBOL examples},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design,
		  Data-Centered_Program_Understanding}
}

@Article{	  hall:automatic,
  author	= {R.J. Hall},
  title		= {Automatic Extraction of Executable program subsets by
		  simultaneous dynamic program slicing},
  journal	= {Automated Software Engineering},
  publisher	= {Kluwer Academic Publishers},
  volume	= {2},
  year		= {1995},
  pages		= {33-53},
  note		= { An algorithm to automatically extract a correctly
		  functioning subset of the code of a system is presented.
		  The technique is based on computing a simultaneous dynamic
		  program slice of the code for a set of representative
		  inputs. Experiments show that the algorithm produces
		  significantly smaller subsets than with existing methods},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Dynamic_Analysis,
		  Program_Slicing}
}

@InProceedings{	  hall:generalized,
  author	= {Robert J. Hall},
  title		= {Generalized Behavior-based Retrieval},
  booktitle	= {Proceedings of the 15th  International Conference on
		  Software Engineering },
  year		= {1993},
  publisher	= {IEEE Computer Society Press},
  month		= apr,
  abstract	= {The user of a large reuse library faces the formidable
		  discovery problem of searching for all and only those
		  components useful in solving the current programming task.
		  This paper describes a retrieval technique that generalizes
		  the simple idea of executing each component on test inputs,
		  reporting those that compute correct outputs. One
		  generalization improves recall by considering small
		  programs constructible from library components, rather than
		  just single components. Furthermore, functional modeling of
		  components allows the technique to handle complex
		  behaviors, such as side effects. I motivate, describe, and
		  analyze the technique and a working prototype, GBR, which
		  has been tested on two libraries: one containing general
		  programming components, the other containing (some) Unix
		  shell commands.},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Dynamic_Analysis,
		  Dynamic_Data_Flow_Analysis}
}

@MastersThesis{	  hanssen:extraktion,
  author	= {Sven Hanssen},
  title		= {Extraktion statischer Traces zur Wiedergewinnung von
		  Protokollen},
  school	= {Institut für Informatik, Universität Stuttgart},
  year		= {2000},
  note		= {The language is German.},
  type		= {Studienarbeit Nr. 1768},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Others}
}

@Article{	  harmann.gallagher:program,
  author	= {Mark Harmann and Keith Brian Gallagher},
  title		= {Program Slicing},
  journal	= {Information and Software Technology},
  year		= {1998},
  key		= {Program Slicing},
  volume	= {40},
  number	= {11-12},
  pages		= {577-582},
  month		= {November},
  note		= {Special issue on program slicing},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Program_Slicing}
}

@Article{	  hattori.ishii:method,
  author	= {Norihide Hattori and Naohiro Ishii},
  title		= {A method to remove variations in source codes},
  journal	= {Information and Software Technology},
  volume	= {38},
  pages		= {25-36},
  year		= {1996},
  abstract	= {Variations in source codes of computer programs cause
		  difficult problems in source code handling systems, such as
		  program understanding systems. This paper proposes a new
		  method to remove these variations. First, a representation
		  method of programs is discussed. The proposed
		  representation is free from three kinds of variations and
		  it can be easily rewritten. Next, a prototype variation
		  removal system is evaluated. The system utilizes the
		  representation and removes 13 kinds of variations by
		  program rewriting. It has removed 20 - 83 \% variations in
		  the source codes implemented by undergraduates and
		  postgraduates. },
  keywords	= {Variation removal; Source code; Rewriting},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Others}
}

@Book{		  hecht:flow,
  title		= {Flow analysis of computer programs},
  author	= {M. Hecht},
  publisher	= { Elsevier North-Holland},
  year		= {1977},
  note		= { A classical book on the theory and implementation of
		  algorithms for data flow analysis},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Static_Analysis,
		  Static_Data_Flow_Analysis}
}

@MastersThesis{	  heiber:semi-automatische,
  author	= {Timo Heiber},
  title		= {Semi-automatische Herleitung von Komponentenprotokollen
		  aus statischen Verwendungsmustern},
  school	= {Institut für Informatik, Universität Stuttgart},
  year		= {2000},
  type		= {Diplomarbeit Nr. 1822},
  note		= {The language is English, even though the title is
		  German.},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Others}
}

@Article{	  horwitz.reps.ea:interprocedural,
  author	= {Horwitz, S. and Reps, T., and Binkley, D.},
  title		= {Interprocedural slicing using dependence graphs},
  journal	= {ACM Transactions on Programming Languages and Systems},
  volume	= {12},
  number	= {1},
  month		= {January},
  year		= {1990},
  pages		= {26-60},
  http		= {http://www.cs.wisc.edu/~reps/reps.html#toplas90},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Program_Slicing}
}

@InProceedings{	  horwitz.reps:use,
  author	= {S. Horwitz and T. Reps},
  title		= {The Use of Program Dependence Graphs in Software
		  Engineering},
  booktitle	= {Proceedings of the 14th  International Conference on
		  Software Engineering },
  pages		= {392--411},
  month		= may,
  year		= {1992},
  abstract	= {This paper describes a language-independent program
		  representation-the program dependence graph-and discusses
		  how program dependence graphs, together with operations
		  such as program slicing, can provide the basis for powerful
		  programming tools that address important software
		  engineering problems, such as understanding what an
		  existing program does and how it works, understanding the
		  differences between several versions of a program, and
		  creating new programs by combining pieces of old programs.
		  The paper primarily surveys work in this area that has been
		  carried out at the University of Wisconsin.},
  http		= {http://www.cs.wisc.edu/wpis/papers/icse92.ps},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Program_Slicing}
}

@InProceedings{	  johnson.ornburn.ea:quick,
  author	= {Bret Johnson and Stephen B. Ornburn and Spencer Rugaber},
  title		= {A Quick Tools Strategy for Program Analysis and Software
		  Maintenance},
  pages		= {206-213},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1992},
  year		= {1992},
  publisher	= {IEEE Computer Society Press},
  month		= nov,
  abstract	= {Most software maintenance tasks are driven by specific
		  customer requests for program corrections or enhancements.
		  These often require detailed analyses of specific code
		  segments. Monolithic tools may not be flexible enough to
		  deal with such specific requests. This paper describes a
		  strategy for quickly producing new special-purpose tools.
		  The strategy combines existing tools including simple,
		  off-the-shelf text processing tools; rule-based,
		  language-specific analysis tools; and a commercial CASE
		  tool.},
  ftp		= {ftp.cc.gatech.edu//pub/groups/reverse/repository/quick.ps}
		  ,
  class		= {Software_Reverse_Engineering,
		  Software_Reverse_Engineering_Tools, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Static_Analysis,
		  Static_Data_Flow_Analysis}
}

@InProceedings{	  johnson.ornburn.ea:quick*1,
  title		= {A quick tools approach to program analysis and software
		  maintenance},
  author	= {B. Johnson and S. Ornburn and S. Rugaber},
  booktitle	= {\cite{SM92}},
  year		= {1992},
  note		= { Describes the use of standard Unix tools like (Awk, Lex,
		  Yacc) for extracting information from PL/M code. The
		  information is then visualized using a commercial CASE tool
		  (Software Through Pictures)},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Static_Analysis}
}

@Unpublished{	  johnson:reverse,
  author	= {Bret Johnson},
  title		= {Reverse Engineering with a CASE Tool},
  month		= oct,
  year		= {1994},
  abstract	= {We examine using a CASE tool, Interactive Development
		  Environment's Software through Pictures (StP), to support
		  reverse engineering. We generate structure charts in StP
		  from the automated analysis of C source code. The
		  advantages of this approach are that one can use the CASE
		  tool's support for drawing, linking, and modifying
		  pictorial notations for program design in order to make it
		  easier to construct a reverse engineering tool.
		  Additionally, one can the use the design representations
		  with the CASE tool to do reengineering for maintenance.},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Code_Views,
		  Software_Reverse_Engineering_Tools}
}

@Article{	  kamkar:application,
  author	= {Mariam Kamkar},
  title		= {Application of Program Slicing in Algorithmic Debugging},
  journal	= {Information and Software Technology},
  year		= {1998},
  key		= {Program Slicing},
  volume	= {40},
  number	= {11-12},
  pages		= {635-646},
  month		= {November},
  note		= {Special issue on program slicing},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Program_Slicing}
}

@TechReport{	  kamper.rugaber:reverse,
  author	= {Kit Kamper and Spencer Rugaber},
  title		= {A Reverse Engineering Methodology for Data Processing
		  Applications},
  number	= {GIT-SERC-90/02},
  institution	= {Software Engineering Center Georgia Institute of
		  Technology, Atlanta, GA},
  year		= {1990},
  month		= mar,
  note		= {Figures are missing},
  abstract	= {Reverse engineering produces a high-level representation
		  of a software system from a low-level one. This paper
		  describes a methodology for reverse engineering that
		  constructs an architectural design for a system from its
		  source code and related documentation. The methodology
		  makes use of several techniques normally used during the
		  forward software development process as well as a new
		  technique called Synchronized Refinement. Synchronized
		  Refinement is a systematic approach to detecting design
		  decisions in source code and relating the detected
		  decisions to the functionality of the system. Examples are
		  given demonstrating the application of the methodology to
		  the reverse engineering of a production software system.},
  ftp		= {ftp.cc.gatech.edu//pub/groups/reverse/repository/synchronized.ps}
		  ,
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Process_Models_for_Reverse_Design,
		  Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design}
}

@Article{	  korel.rilling:dynamic,
  author	= {Bogdan Korel and Jürgen Rilling},
  title		= {Dynamic Program Slicing Methods},
  journal	= {Information and Software Technology},
  year		= {1998},
  key		= {Program Slicing},
  volume	= {40},
  number	= {11-12},
  pages		= {647-660},
  month		= {November},
  note		= {Special issue on program slicing},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Program_Slicing}
}

@Article{	  krinke.snelting:program,
  author	= {Jens Krinke and Gregor Snelting},
  title		= {Program Slicing},
  journal	= {Information and Software Technology},
  year		= {1998},
  key		= {Program Slicing},
  volume	= {40},
  number	= {11-12},
  pages		= {661-676},
  month		= {November},
  note		= {Special issue on program slicing},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Program_Slicing}
}

@Article{	  lakhotia.deprez:restructuring,
  author	= {Arun Lakhotia and Jean-Christophe Deprez},
  title		= {Restructuring Programs by Tucking Statements into
		  Functions},
  journal	= {Information and Software Technology},
  year		= {1998},
  key		= {Program Slicing},
  volume	= {40},
  number	= {11-12},
  pages		= {677-690},
  month		= {November},
  note		= {Special issue on program slicing},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Program_Slicing}
}

@InProceedings{	  linos.aubet.ea:care,
  author	= {Panagiotis Linos and Philippe Aubet and Laurent Dumas and
		  Yan Helleboid and Patricia Lejeune and Philippe Tulula},
  title		= {CARE: An Environement for Understanding and
		  Re--engineering C--Programs},
  pages		= {130--139},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1993},
  year		= {1993},
  publisher	= {IEEE Computer Society Press},
  month		= sep,
  abstract	= {The focus of this paper is on facilitating incremental
		  understanding and re-enginering of existing C programs. A
		  software environement called C.A.R.E. (Computer-Aided
		  Re-engineering) is used as a vehicle towards that goal.
		  CARE maintains a repository of control-flow and data-flow
		  dependencies (i.e. entities and their relations) of C
		  programs. These dependencies can be visualized using a
		  novel representation model. Moreover, CARE entails
		  transformation tools that support various ways of
		  displaying program dependencies and facilitate incremental
		  program modifications. An empirical evaluation of the CARE
		  environement using small size C programs is performed. In
		  addition, CARE is used in order to modify the source code
		  of a medium-to-large size program. The results from this
		  empirical evaluation of CARE indicate that its presentation
		  model and transformation tools is a promising step towards
		  improving the effectiveness of understanding and
		  re-engineering existing C programs. Finally, the authors
		  discuss some issues raised during the modification exercise
		  with CARE when using a medium-to-large size program.},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Code_Views}
}

@InProceedings{	  long.clarke:task,
  author	= {D. L. Long and L. A. Clarke},
  title		= {Task Interaction Graphs for Concurrency Analysis},
  booktitle	= {Proceedings of the 11th  International Conference on
		  Software Engineering },
  pages		= {44--52},
  month		= may,
  year		= {1989},
  abstract	= {A representation for concurrent programs called task
		  interaction graphs, is presented. Task interaction graphs
		  divide a program into maximal sequential regions connected
		  by edges representing task interactions. This
		  representation is illustrated. It is shown how task
		  interaction graphs can be used to create concurrency graph
		  representations that are much smaller than those created
		  from control flow graph representations. Both task
		  interaction graphs and their corresponding concurrency
		  graphs facilitate analysis of concurrent programs. Some
		  analyses and optimizations on these representations are
		  also described.},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Code_Views}
}

@Article{	  marlowe.ryder:properties,
  author	= {Marlowe and Ryder},
  title		= {Properties of Data Flow Frameworks. {A} Unified Model},
  journal	= {Acta Informatica},
  publisher	= {Springer-Verlag},
  volume	= {28},
  year		= {1990},
  pages		= {121-163},
  note		= { An overview of data flow frameworks and their
		  characterizing properties is given. Contains many
		  references to the field of data flow analysis},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Static_Analysis,
		  Static_Data_Flow_Analysis}
}

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

@InCollection{	  nillson:translation,
  title		= {The translation of {COBOL} data structures to
		  entity-relationship conceptual schema},
  author	= {E. Nillson},
  editor	= {P. Chen},
  booktitle	= {Entity Relationship Approach: The Use of {ER} Concepts in
		  Knowledge Representation},
  publisher	= {{IEEE} CS Press},
  year		= {1986},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design,
		  Data-Centered_Program_Understanding}
}

@InProceedings{	  olshefski.cole:prototype,
  author	= {D. Olshefski and A. Cole},
  title		= {A prototype system for static and dynamic program
		  understanding},
  booktitle	= {Proceedings of the 1st  Working Conference on Reverse
		  Engineering },
  pages		= {93--106},
  year		= {1993},
  note		= { Describes the experimental PUNDIT system that combines
		  static and dynamic information for program understanding.
		  It comprises a static analyzer for C source code and a,
		  mostly language-independent, graphical user interface.
		  Gives various examples of program views},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Static_Analysis,
		  Dynamic_Analysis, Code_Views}
}

@Article{	  oman.cook:book,
  title		= {The book paradigm for improved maintenance},
  author	= {P.W. Oman and C.R. Cook},
  journal	= {{IEEE} Software},
  volume	= {7},
  number	= {1},
  pages		= {39--45},
  year		= {1990},
  note		= { It is shown that traditional typographical formats used
		  in books work very well to aid program understanding},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design,
		  Reformatting_and_Markup_Languages}
}

@Article{	  ott.bieman:program,
  author	= {Linda M. Ott and James M. Bieman},
  title		= {Program Slices as an Abstraction for Cohesion
		  Measurement},
  journal	= {Information and Software Technology},
  year		= {1998},
  key		= {Program Slicing},
  volume	= {40},
  number	= {11-12},
  pages		= {691-700},
  month		= {November},
  note		= {Special issue on program slicing},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Program_Slicing}
}

@Article{	  paul.prakash:framework,
  title		= {A framework for source code search using program
		  patterns},
  author	= {S. Paul and A. Prakash},
  journal	= {IEEE Transactions on Software Engineering},
  pages		= {463--475},
  volume	= {20},
  number	= {6},
  year		= {1994},
  note		= { It is argued that existing solutions to locating source
		  code fragments that match certain patterns are
		  insufficient. A framework in which pattern languages are
		  used to specify interesting code features is presented.
		  These are obtained by extending the source programming
		  language with pattern-matching symbols. This is implemented
		  in a tool called SCRUPLE},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design,
		  Source_Code_Queries}
}

@Article{	  paul.prakash:supporting,
  author	= {S. Paul and A. Prakash},
  title		= {Supporting Queries on Source Code: A Formal Framework},
  journal	= {International Journal of Software Engineering and
		  Knowledge Engineering},
  volume	= {4},
  number	= {3},
  pages		= {325-348},
  year		= {1994},
  note		= { A source code query system is a powerful mechanism to
		  obtain crucial information necessary to successfully
		  performing a reverse engineering task. A source code
		  algebra (SCA) is developed which is strongly based on
		  relational algebras as well as on many sorted algebras. Two
		  types of data types are distinguished in the source code
		  algebra model: \begin{itemize} \item atomic data types,
		  such as integer, float, etc. \item composite data types
		  (so-called objects): \begin{itemize} \item singular
		  objects, such as while-statement, identifier, etc. \item
		  collective objects, such as statement-list, etc.
		  \end{itemize} \end{itemize} The objects are extended with
		  four kinds of attributes, namely, components, references,
		  annotations, and methods. An extensive set of source code
		  algebra operators are defined, such operators defined for
		  atomic data types, individual objects, and collections,
		  i.e., sets and sequences. The operators for the collections
		  are strongly influenced by the operators from the
		  relational algebra domain},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design,
		  Source_Code_Queries}
}

@InProceedings{	  platoff.wagner.ea:integrated,
  author	= {Michael Platoff and Michael Wagner and Joseph Camaratta},
  title		= {An Integrated Program Representation and Toolkit for the
		  Maintenance of C Programs},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1991},
  year		= {1991},
  pages		= {129-137},
  organization	= {IEEE},
  publisher	= {IEEE Computer Society Press},
  abstract	= {Maintaining large software systems has become an
		  increasingly common and expensive task for many
		  organizations. Understanding and modifying existing
		  programs is a major goal of the authors' Maintainer's
		  Assistant (MA) project, an environment for the maintenance
		  of software systems written in the C language. The authors
		  describe an integrated program representation that presents
		  views of the source text, architecture, syntax, static
		  semantics, and control and data flow of software systems.
		  Changes to these views are provided by a transformation
		  toolkit that supports structured modifications to the
		  representation. Modifications in one view are reflected in
		  related views. The representation and toolkit support all
		  of C, including features of the C preprocessor.},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Code_Views,
		  Reengineering_Tools}
}

@Article{	  podgurski.pierce:retrieving,
  key		= {Podgurski \& Pierce, 1993},
  author	= {Andy Podgurski and Lynn Pierce},
  title		= {Retrieving Reusable Software by Sampling Behaviour},
  journal	= { ACM  Transactions on Software Engineering and
		  Methodology},
  year		= {1993},
  volume	= {2},
  number	= {3},
  pages		= {286-303},
  month		= jul,
  abstract	= {A new method, called behavior sampling, is proposed for
		  automated retrieval of reusable components from software
		  libraries. Behavior sampling exploits the property of
		  software that distinguishes it from other forms of text:
		  executability. Basic behavior sampling identifies relevant
		  routines by executing candidates on a searcher supplied
		  sample of operational inputs and by comparing their output
		  provided by the searcher. The probabilistic basis for
		  behavior sampling is described, and experimental results
		  are reported that suggest that basic behavior sampling
		  exhibits high precision when used with small samples.
		  Extensions to basic behavioral sampling are proposed to
		  improve its recall and to make it applicable to the
		  retrieval of abstract data types and object classes.},
  class		= {Software_Reverse_Engineering, Re-Use,
		  Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Dynamic_Analysis,
		  Dynamic_Data_Flow_Analysis}
}

@InProceedings{	  premerlani.blaha:approach,
  author	= {W. Premerlani and M. Blaha},
  title		= {An approach for reverse engineering of relational
		  databases},
  booktitle	= {Proceedings of the 1st  Working Conference on Reverse
		  Engineering },
  pages		= {151--160},
  year		= {1993},
  note		= { Experience report describing the reverse engineering of
		  several relational databases to OMT (Object Modeling
		  Technique) diagrams. The process is partly automated using
		  a variety of tools},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design,
		  Data-Centered_Program_Understanding}
}

@InProceedings{	  rajlich.damaskinos:algorithm,
  author	= {Vaclav Rajlich and Nicolas Damaskinos},
  title		= {Algorithm for Graphic Layout in VIFOR},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1990},
  year		= {1990},
  pages		= {142-145},
  organization	= {IEEE},
  publisher	= {IEEE Computer Society Press},
  abstract	= {VIFOR is a tool for maintenance of large FORTRAN programs.
		  It contains a database which stores information on all
		  nonlocal declaractions of the programs (i.e. subroutines,
		  functions, commons), all source files, and all relations
		  among them.
		  
		  The programmer accesses this database by queries which
		  produce views. Each view is a subset of the information
		  stored in the database. VIFOR displays these views in
		  browsers, which are specialized windows displaying the
		  views graphically.},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Code_Views,
		  Software_Reverse_Engineering_Tools, VIFOR}
}

@InProceedings{	  rajlich:incremental,
  author	= {Vaclav Rajlich},
  title		= {Incremental Redocumentation with Hypertext},
  booktitle	= {1st  European Conference on Software Maintenance and
		  Reengineering 97},
  month		= mar,
  year		= {1997},
  publisher	= {IEEE Computer Society Press},
  abstract	= {Redocumentation is the recovery and recording of software
		  comprehension. Since software comprehension is the most
		  expensive part of software maintenance, redocumentation is
		  the key to software maintainability. This paper describes
		  the process and tools of incremental redocumentation where
		  the comprehension of the software is recorded in hypertext,
		  in the style of World Wide Web. The paper describes the
		  tools which support redocumentation, and gives several
		  examples. },
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Hypertext}
}

@Article{	  reps:program,
  author	= {Thomas Reps},
  title		= {Program Analysis via Graph Reachability},
  journal	= {Information and Software Technology},
  year		= {1998},
  key		= {Program Slicing},
  volume	= {40},
  number	= {11-12},
  pages		= {701-726},
  month		= {November},
  note		= {Special issue on program slicing},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Program_Slicing}
}

@InProceedings{	  reubenstein.piazza.ea:separating,
  author	= {H. Reubenstein and R. Piazza and S. Roberts},
  title		= {Separating parsing and analysis in reverse engineering
		  tools},
  booktitle	= {Proceedings of the 1st  Working Conference on Reverse
		  Engineering },
  pages		= {117--125},
  year		= {1993},
  note		= { Experience report describing the extension of an existing
		  analysis tool with a new syntactic front-end. Concludes
		  that language-independence as well separation of parsing
		  and analysis are essential for extensibility},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Static_Analysis}
}

@InProceedings{	  ritsch.sneed:reverse,
  author	= {H. Ritsch and H. Sneed},
  title		= {Reverse engineering programs via dynamic analysis},
  booktitle	= {Proceedings of the 1st  Working Conference on Reverse
		  Engineering },
  pages		= {192--201},
  year		= {1993},
  note		= { Describes a dynamic analysis of COBOL programs. By
		  inspection of transaction files assertions are generated
		  capturing the input and output requirements of each
		  database operation},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Dynamic_Analysis}
}

@Unpublished{	  rugaber.stirewalt.ea:detecting,
  author	= {Spencer Rugaber and Kurt Stirewalt and Linda M. Wills},
  title		= {Detecting Interleaving},
  organization	= {College of Computing, Georgia Institute of Technology},
  address	= {Atlanta, Georgia 30332-0280},
  email		= {spencer@cc.gatech.edu},
  abstract	= {The various goals and requirements of a system are
		  realized in software as fragments of code that are
		  typically ``interleaved'' in that they may be woven
		  together in the same contigous textual area of code. The
		  fragments of code are often delocalized and overlap rather
		  than beiing composed in a simple linear sequence.
		  Interleaving severely complicates software comprehension
		  and maintenance. To address this problem, we are developing
		  analysis tools, based on the Software Refinery. This paper
		  describes our experiences in detecting interleaving in a
		  corpus of mathematical software written in Fortran from the
		  Jet Propulsion Laboratory. In particular, it discusses how
		  feasible it is to detect interleaving of various types and
		  the ability of existing tools to assist these types of
		  detection.},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Others}
}

@InProceedings{	  ryder:ismm,
  author	= {Barbara G. Ryder},
  title		= {ISMM: The Incremental Software Maintenance Manager},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1989},
  year		= {1989},
  pages		= {142-157},
  organization	= {IEEE},
  publisher	= {IEEE Computer Society Press},
  abstract	= {ISMM, the Incremental Software Maintenance Manager, is a
		  prototype software maintenance tool which uses incremental
		  static analysis to assess the scope of proposed source code
		  changes. These effects can be predicted a priori, that is
		  without actually having to perform the software change,
		  thus anabling maintainers to choose between alternative
		  enhancements or bug fixes on the basis of their predicted
		  system impact. Incremental analysis efficiently updates
		  data flow information describing the definition, use and
		  sharing of data in an evolving software system, keeping
		  this information consistent with the current system state.
		  ISMM addresses problems in maintenance, program
		  understanding enhancement, system restructuring and
		  intelligent code reuse for C systems. Recently, ISMM has
		  provided the basis for an empirical study of the calling
		  structure of C systems. ISMM has also been used to profile
		  the on the average performance of our incremental analysis
		  algorithms; it clearly validates their usefulness,
		  especially for large systems. This paper describes the
		  design and implementation of ISMM and summarizes our
		  empirical studies.},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Static_Analysis,
		  Static_Data_Flow_Analysis}
}

@InProceedings{	  sametinger:tool,
  author	= {Johannes Sametinger},
  title		= {A Tool for the Maintenance of C++ Programs},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1990},
  year		= {1990},
  pages		= {54-59},
  organization	= {IEEE},
  publisher	= {IEEE Computer Society Press},
  abstract	= {This paper describes a tool that helps programmers
		  understand object-oriented software systems written in C++,
		  a language that is expected to gain widespread use in
		  industry. This task is accomplished by providing
		  information about the set of classes and files comprising
		  the system and the relationships among them. The tool
		  described enables its users to easily browse through the
		  system based on the relations amoung its classes, files and
		  even identifiers. In addition, the flexible use of global
		  text styles enhances the readability of the source code.
		  
		  The second part of the paper describes some details about
		  the implementation of the tool. In particular, problems are
		  mentioned that arise when performing static analysis of C++
		  programs. This analysis is necessary for obtaining
		  information needed about the program system.
		  
		  The primary goal of developing the tool has been to support
		  software maintenance, but its use is in no way limited to
		  that process},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Static_Analysis,
		  Static_Data_Flow_Analysis}
}

@InProceedings{	  servello:logiscope,
  author	= {Mark A. Servello},
  title		= {LOGISCOPE and the Software Maintenance Crisis},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1990},
  year		= {1990},
  pages		= {104},
  organization	= {IEEE},
  publisher	= {IEEE Computer Society Press},
  abstract	= {Gaining a complete understanding of unfamiliar source code
		  is fundamental to effective maintenance of that software.
		  LOGISCOPE performs a fast and consistent source code
		  analysis in wide variety of languages to produce graphic
		  aids and complexity metrics which can drastically reduce
		  both time and error in gaining this understanding.},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Code_Views,
		  Software_Reverse_Engineering_Tools, LOGISCOPE}
}

@InProceedings{	  storey.mueller:graph,
  author	= {M.-A. D. Storey and H. Mueller},
  title		= {Graph Layout adjustment strategies},
  key		= {graph layout,},
  booktitle	= {Graph Drawing 1995 Proceedings},
  year		= {1995},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Code_Views,
		  Software_Reverse_Engineering_Tools, Rigi}
}

@InProceedings{	  storey.mueller:manipulating,
  author	= {M-A D Storey and H. Mueller},
  title		= {Manipulating and Documenting Software Structures using
		  SHriMP Views},
  key		= {program understanding, reverse engineering, reengineering,
		  software visualization, fisheye views},
  pages		= {275-285},
  booktitle	= {International Conference in Software Maintenance},
  year		= {1995},
  publisher	= {IEEE Computer Society Press},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Code_Views,
		  Software_Reverse_Engineering_Tools, Rigi}
}

@Article{	  tan.ling:recovery,
  title		= {Recovery of Object-Oriented Design from Existing
		  Data-intensive Business Programs},
  author	= {H.B.T. Tan and T.W. Ling},
  journal	= {Information and Software Technology},
  volume	= {37},
  number	= {2},
  pages		= {67--77},
  year		= {1995},
  note		= { A method is given for the recovery of a specification
		  from an existing data-intensive business program using an
		  augmented model that is proposed in the paper},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design,
		  Data-Centered_Program_Understanding}
}

@Article{	  tangorra.chiarolla:methodology,
  title		= {A Methodology for Reverse Engineering Hierarchical
		  Databases},
  author	= {F. Tangorra and D. Chiarolla},
  journal	= {Information and Software Technology},
  volume	= {37},
  number	= {4},
  pages		= {225--231},
  year		= {1995},
  note		= { The steps of a reverse engineering process for
		  translating a hierarchical data scheme into a conceptual
		  description in the extended entity-relationship model are
		  described. Contains a case study},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design,
		  Data-Centered_Program_Understanding}
}

@Article{	  tip:survey,
  title		= {A survey of program slicing techniques},
  author	= {F. Tip},
  journal	= {Journal of programming languages},
  volume	= {3},
  pages		= {121--189},
  year		= {1995},
  note		= { Surveys the state-of-the-art in program slicing and gives
		  many references to the literature},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Program_Slicing}
}

@InProceedings{	  tonella.antoniol.ea:variable,
  author	= {Paolo Tonella and Giuliano Antoniol and Roberto Fiutem and
		  Ettore Merlo},
  title		= {Variable Precision Reaching definitions Analysis for
		  Software Maintenance},
  booktitle	= {1st  European Conference on Software Maintenance and
		  Reengineering 97},
  month		= mar,
  year		= {1997},
  publisher	= {IEEE Computer Society Press},
  abstract	= {A flow analyzer can be very helpful in the process of
		  program understanding, by providing the programmer with
		  different views of the code. As the documentation is often
		  incomplete or inconsistent, it is extremely useful to
		  extract the information a programmer may need directly from
		  the code. Program understanding activities are interactive,
		  thus program analysis tools may be asked for quick answers
		  by the maintainer. Therefore the control on the trade-off
		  between accuracy and efficiency should be given to the user.
		  
		  This paper presents an approach to interprocedural reaching
		  definitions flow analysis based on three levels of
		  precision depending on the sensitivity to the calling
		  context and the control flow. A lower precision degree
		  produces an overestimate of the data dependences in a
		  program. The result is anyhow conservative (all dependences
		  which hold are surely reported), and definitely faster than
		  the more accurate counterparts. A tool supporting reaching
		  definition analysis in the three variants has been
		  developed. The results on a test suite show that three
		  orders of magnitude can be gained in execution times by the
		  less accurate analysis, but 57.4 % extra dependences are on
		  average added. The intermediate variant is much more
		  precise (1.6 % extra dependences), but gains less in times
		  (one order of magnitude). },
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Static_Analysis,
		  Static_Data_Flow_Analysis}
}

@InProceedings{	  vanek.culp:static,
  author	= {Leonard I. Vanek and Mark N. Culp},
  title		= {Static Analysis of Program Source Code using EDSA},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1989},
  year		= {1989},
  pages		= {192-199},
  organization	= {IEEE},
  publisher	= {IEEE Computer Society Press},
  abstract	= {ESDA is a tool that uses static analysis of source code to
		  help gain an understanding of existing code. This may be
		  for the purpose of tracking down a bug or to determine in
		  advance whether an intended change will have any
		  undesirable side effects. In either case, the phase of the
		  development life cycle that will most benefit from a tool
		  like EDSA is the maintenance phase.
		  
		  ESDA provides three kinds of facilities. It helps to browse
		  through code following either the control flow or data flow
		  rather than the order in which the code happens to be
		  written. It displays code with unimportant source lines
		  elided, so that the user can get a more global view of the
		  program. Finally, it provides search management to make it
		  easier to examine all possibilities when browsing.},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Static_Analysis,
		  Static_Data_Flow_Analysis}
}

@TechReport{	  webster:desire-88,
  author	= {Dallas Webster},
  title		= {DESIRE-88 Prototype Tools},
  institution	= {MCC},
  year		= {1989},
  type		= {Technical Report},
  number	= {STP-069-89},
  month		= feb,
  abstract	= {DESIRE is an STP activity whose goal is to develop and
		  support a process for recovering design information from
		  the artifacts (e.g. code, specifications and user
		  documentation) of existing designs. This report presents a
		  snapshot of the initial phase of that activity, showing its
		  status by discussing some prototype tools that we have been
		  experimenting with an evaluating.},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design}
}

@Article{	  weiser:foreword,
  author	= {Mark Weiser},
  title		= {Foreword to Special Issue on Program Slicing},
  journal	= {Information and Software Technology},
  year		= {1998},
  key		= {Program Slicing},
  volume	= {40},
  number	= {11-12},
  pages		= {575-576},
  month		= {November},
  note		= {Special issue on program slicing},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Program_Slicing}
}

@Article{	  weiser:program,
  title		= {Program slicing},
  author	= {M. Weiser},
  journal	= {IEEE Transactions on Software Engineering},
  volume	= {10},
  number	= {4},
  pages		= {352--357},
  year		= {1984},
  note		= { In this paper some properties of slices are presented. It
		  is shown that the use of data-flow analysis is sufficient
		  to find approximate slices of the generally unsolvable
		  problem of finding statement-minimal slices},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Program_Slicing}
}

@InProceedings{	  wilde.huitt.ea:dependence,
  author	= {Norman Wilde and Ross Huitt and Scott Huitt},
  title		= {Dependence Analysis Tools: Reusable Components for
		  Software Maintenance},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1989},
  year		= {1989},
  pages		= {126-131},
  organization	= {IEEE},
  publisher	= {IEEE Computer Society Press},
  abstract	= {Software Maintenance is costly because of the many complex
		  interrelationships in a large software system; an
		  understanding of these program dependencies is fundamentral
		  to efficient software change. This paper describes a
		  general purpose toolset that is now being developed to
		  capture and analyze software dependencies. The tools are
		  designed to serve as reusable components. They may be used
		  not only to aid programmers directly in understanding
		  programs but also as a basis from which other specialized
		  tools can be constructed.
		  
		  The tools use the concept of a dependency graph as a basic
		  abstraction to simplify the understanding of software
		  relationships. Definitional, calling, functional and
		  data-flow dependencies are analyzed. An external dependency
		  graph for each function is developed to encapsulate the
		  effects of function calls.},
  class		= {Software_Reverse_Engineering,
		  Intermediate_Representations_of_Source_Code, Using_graphs,
		  Reverse_Design, Fundamental_Methods_in_Reverse_Design,
		  Static_Analysis, Static_Data_Flow_Analysis}
}

@Article{	  wilde.huitt:reusable,
  title		= {A reusable toolset for software dependency analysis},
  author	= {N. Wilde and R. Huitt},
  journal	= {Journal of Systems and Software},
  volume	= {14},
  number	= {2},
  pages		= {97--102},
  year		= {1991},
  note		= { A general purpose tool set that has been developed to
		  capture and analyse software dependencies is described. A
		  prototype of this so-called dependency analysis tool set
		  has been implemented to analyze C code},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Static_Analysis}
}

@Article{	  wolf.clarke.ea:adapic,
  key		= {Wolf et al.},
  author	= {A. L. Wolf and L. A. Clarke and J. C. Wileden},
  title		= {The AdaPIC Tool Set: Supporting Interface Control and
		  Analysis Throughout the Software Development Process},
  journal	= {IEEE Transactions on Software Engineering},
  pages		= {250--263},
  volume	= {15},
  number	= {3},
  month		= mar,
  year		= {1989},
  location	= {CMU E & S Library},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Static_Analysis,
		  Static_Data_Flow_Analysis}
}