References of Dynamic_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{	  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}
}

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

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

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