@article {14758,
	title = {Recovering system specific rules from software repositories},
	journal = {SIGSOFT Softw. Eng. Notes},
	volume = {30},
	year = {2005},
	month = {2005/05//},
	pages = {1 - 5},
	abstract = {One of the most successful applications of static analysis based bug finding tools is to search the source code for violations of system-specific rules. These rules may describe how functions interact in the code, how data is to be validated or how an API is to be used. To apply these tools, the developer must encode a rule that must be followed in the source code. The difficulty is that many of these system-specific rules are undocumented and "grow" over time as the source code changes. Most research in this area relies on expert programmers to document these little-known rules. In this paper we discuss a method to automatically recover a subset of these rules, function usage patterns, by mining the software repository. We present a preliminary study that applies our work to a large open source software project.},
	keywords = {data warehouse and repository, debugging aids, design, experimentation, measurement, performance},
	isbn = {0163-5948},
	doi = {10.1145/1082983.1083144},
	author = {Williams, Chadd C and Hollingsworth, Jeffrey K}
}
@conference {14772,
	title = {Recompilation for debugging support in a JIT-compiler},
	booktitle = {Proceedings of the 2002 ACM SIGPLAN-SIGSOFT workshop on Program analysis for software tools and engineering},
	series = {PASTE {\textquoteright}02},
	year = {2002},
	month = {2002///},
	pages = {10 - 17},
	publisher = {ACM},
	organization = {ACM},
	address = {Charleston, South Carolina, USA},
	abstract = {A static Java compiler converts Java source code into a verifiably secure and compact architecture-neutral intermediate format, called Java byte codes. The Java byte codes can be either interpreted by a Java Virtual Machine or translated into native code by Java Just-In-Time compilers. Static Java compilers embed debug information in the Java class files to be used by the source level debuggers. However, the debug information is generated for architecture independent byte codes and most of the debug information is valid only when the byte codes are interpreted. Translating byte codes into native instructions puts a limitation on the amount of usable debug information that can be used by source level debuggers. In this paper, we present a new technique to generate valid debug information when Just-In-Time compilers are used. Our approach is based on the dynamic recompilation of Java methods by a fast code generator and lazily generates debug information when it is required. We also present three implementations for field watch support in the Java Virtual Machine Debugger Interface to investigate the runtime overhead and code size growth by our approach.},
	keywords = {algorithms, debug information, debugging aids, dynamic recompilation, field access watch, java, java virtual machine debugger interface, just-in-time compilation, measurement, performance},
	isbn = {1-58113-479-7},
	doi = {10.1145/586094.586100},
	author = {Tikir, Mustafa M. and Hollingsworth, Jeffrey K and Lueh,Guei-Yuan}
}
