References of Dynamic_Data_Flow_Analysis

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

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