References of Static_Analysis

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

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

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

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

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

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

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

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

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

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

@InProceedings{	  livadas.roy:program,
  author	= {Panos E. Livadas and Prabal K. Roy},
  title		= {Program Dependence Analysis},
  pages		= {356-365},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1992},
  year		= {1992},
  publisher	= {IEEE Computer Society Press},
  month		= nov,
  abstract	= {It is generally recognized that one of the reasons that
		  software maintenance is so costly is that each modification
		  to a program must take into account the numerous complex
		  interrelationships in the existing software; an
		  understanding of program dependences is fundamental to
		  efficient software change. Such dependences can be of the
		  following types, data flow, calling, and functional
		  dependences. Furthermore, as the software community
		  gradually begins to move toward a more object-oriented
		  perspective on software development, it will become
		  increasingly important to be able to 'objectify' existing
		  software systems. Successful maintenance requires precise
		  knowledge of the data items in a system, the ways these
		  items are created and modified, and their relationships
		  between one another.
		  
		  In this paper the authors address these two issues. First,
		  they will discuss three methods of identifying objects the
		  first two of which were suggested by Liu and Wilde; the
		  third method is one that is proposed in this paper and is
		  based on the determination of the receiver of a procedure.
		  We believe that the latter method is one that is more
		  natural and precise than the former two. Second, algorithms
		  that perform precise interprocedural flow-sensitive
		  dependency analysis, as well as algorithms that identify
		  'objects', are introduced. Furthermore, the internal
		  program representation that we emply, the parse-tree-based
		  system dependence graph (SDG), is briefly discussed.
		  Finally, a unique tool that we have developed is presented
		  that accepts a subset of ANSI C (or Pascal) as input and
		  which implements all algorithms discussed in this paper.},
  class		= {Software_Reverse_Engineering,
		  Intermediate_Representations_of_Source_Code, Using_graphs,
		  Static_Analysis, Static_Data_Flow_Analysis,
		  Software_Reverse_Engineering, Re-Use}
}

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

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

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

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