Identifying Failure Causes in Java Programs: An Application of Change Impact Analysis

During program maintenance, a programmer may make changes that enhance program functionality or fix bugs in code. Then, the programmer usually will run unit/regression tests to prevent invalidation of previously tested functionality. If a test fails unexpectedly, the programmer needs to explore the edit to find the failure-inducing changes for that test. Crisp uses results from Chianti, a tool that performs semantic change impact analysis, to allow the programmer to examine those parts of the edit that affect the failing test. Crisp then builds a compilable intermediate version of the program by adding a programmer-selected partial edit to the original code, augmenting the selection as necessary to ensure compilation. The programmer can reexecute the test on the intermediate version in order to locate the exact reasons for the failure by concentrating on the specific changes that were applied. In nine initial case studies on pairs of versions from two real Java programs, Daikon and Eclipse jdt compiler, we were able to use Crisp to identify the failure-inducing changes for all but 1 of 68 failing tests. On average, 33 changes were found to affect each failing test (of the 67), but only 1-4 of these changes were found to be actually failure-inducing

[1]  Gregg Rothermel,et al.  An empirical comparison of dynamic impact analysis algorithms , 2004, Proceedings. 26th International Conference on Software Engineering.

[2]  Andreas Zeller,et al.  Yesterday, my program worked. Today, it does not. Why? , 1999, ESEC/FSE-7.

[3]  Václav Rajlich,et al.  JRipples: a tool for program comprehension during incremental change , 2005, 13th International Workshop on Program Comprehension (IWPC'05).

[4]  Frank Tip,et al.  A survey of program slicing techniques , 1994, J. Program. Lang..

[5]  Barbara G. Ryder,et al.  Crisp: a debugging tool for Java programs , 2005, 21st IEEE International Conference on Software Maintenance (ICSM'05).

[6]  David Grove,et al.  A Framework for Selective Recompilation in the Presence of Complex Intermodule Dependencies , 1995, 1995 17th International Conference on Software Engineering.

[7]  Stuart I. Feldman,et al.  Make — a program for maintaining computer programs , 1979, Softw. Pract. Exp..

[8]  Mikhail Dmitriev.  Language-specific make technology for the Java programming language , 2002, OOPSLA '02.

[9]  Gregg Rothermel,et al.  Whole program path-based dynamic impact analysis , 2003, 25th International Conference on Software Engineering, 2003. Proceedings..

[10]  Rolf Adams,et al.  The cost of selective recompilation and environment processing , 1994, TSEM.

[11]  Alessandro Orso,et al.  Leveraging field data for impact analysis and regression testing , 2003, ESEC/FSE-11.

[12]  Jens Gustavsson.  A classification of unanticipated runtime software changes in Java , 2003, International Conference on Software Maintenance, 2003. ICSM 2003. Proceedings..

[13]  Václav Rajlich,et al.  Incremental change in object-oriented programming , 2004, IEEE Software.

[14]  Frank Tip,et al.  Chianti: A Prototype Change Impact Analysis Tool for Java , 2003 .

[15]  Paolo Tonella,et al.  Using a Concept Lattice of Decomposition Slices for Program Understanding and Impact Analysis , 2003, IEEE Trans. Software Eng..

[16]  Peter Fritzson,et al.  Semi-automatic fault localization and behavior verification for physical system simulation models , 2003, 18th IEEE International Conference on Automated Software Engineering, 2003. Proceedings..

[17]  Frank Tip,et al.  Chianti: a tool for change impact analysis of java programs , 2004, OOPSLA.

[18]  David Chenho Kung,et al.  Change impact identification in object oriented software maintenance , 1994, Proceedings 1994 International Conference on Software Maintenance.

[19]  Frank Tip,et al.  Finding Failure-Inducing Changes using Change Classification , 2005 .

[20]  Ken Kennedy,et al.  Efficient recompilation of module interfaces in a software development environment , 1987, SDE 2.

[21]  A. Jefferson Offutt,et al.  Algorithmic analysis of the impacts of changes to object-oriented software , 2000, Proceedings. 34th International Conference on Technology of Object-Oriented Languages and Systems - TOOLS 34.

[22]  Eugene H. Spafford,et al.  Critical slicing for software fault localization , 1996, ISSTA '96.

[23]  Guy L. Steele,et al.  The Java Language Specification , 1996 .

[24]  William G. Griswold,et al.  Dynamically discovering likely program invariants to support program evolution , 1999, Proceedings of the 1999 International Conference on Software Engineering (IEEE Cat. No.99CB37002).

[25]  Guy L. Steele,et al.  Java Language Specification, Second Edition: The Java Series , 2000 .

[26]  Frank Tip,et al.  Change impact analysis for object-oriented programs , 2001, PASTE '01.

[27]  Xiangyu Zhang,et al.  Locating faulty code using failure-inducing chops , 2005, ASE.

[28]  Linda Torczon,et al.  Interprocedural optimization: eliminating unnecessary recompilation , 1986, SIGPLAN '86.

[29]  Yong Jiang,et al.  Tracker - a tool for change propagation in Java , 2003, Seventh European Conference onSoftware Maintenance and Reengineering, 2003. Proceedings..

[30]  Walter F. Tichy,et al.  Smart recompilation , 1986, TOPL.