Csmr13c.ppt
Upcoming SlideShare
Loading in...5
×

Like this? Share it with your network

Share

Csmr13c.ppt

  • 218 views
Uploaded on

Software evolution, anti-patterns, co-changes, macro-co-changes, faults

Software evolution, anti-patterns, co-changes, macro-co-changes, faults

More in: Technology
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Be the first to comment
    Be the first to like this
No Downloads

Views

Total Views
218
On Slideshare
210
From Embeds
8
Number of Embeds
1

Actions

Shares
Downloads
0
Comments
0
Likes
0

Embeds 8

http://www.ptidej.net 8

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
    No notes for slide

Transcript

  • 1. Jaafar, YannGuéhéneuc, Fehmi Jaafar, Yann-Gaël Guéhéneuc, Sylvie Hamel, and Bram Adams Université de Montréal École Polytechnique de Montréal Quebec Canada 1
  • 2. 1. Introduction 2. Related Work 3. Problem Statement 4. Empirical Study 5. Research Questions 6. Results 7. Ongoing Work 8. Conclusion 2
  • 3. Programs evolve continuously, requiring constant maintenance and development. Features are added and faults are fixed. Programs become more complex over time and thus, harder to maintain. This decay could be detected by measuring the instability of the program, a poor code quality and a high fault rates.. 3
  • 4. Change-Log Approaches[1] use process metrics extracted from the versioning system, assuming that recently or frequently changed classes are the most probable source of faults. Code-Metrics approaches[2] use source code metrics, assuming that complex or larger classes are more fault-prone. Ostrand et al. [3] found that 20% of classes contains 80% of faults. At the same time, these 20% of classes accounted for 50% of the source code. Assuming that all classes are considered to have the same likelihood for faultproneness is not realistic. Not all classes are there to last forever, some are meant for experimentation, so it could be expected that they have more faults. [1] A. E. Hassan, “Predicting faults using the complexity of code changes,” in Proceedings of the 31st International Conference on Software Engineering, 2009. [2] R. Moser, W. Pedrycz, and G. Succi, “A comparative analysis of the efficiency of change metrics and static code attributes for defect prediction,” in Proceedings of the 30th international conference on Software engineering, 2008 [3] T. Ostrand, E. Weyuker, and R. Bell, “Predicting the location and number of faults in large software systems,” Software Engineering, IEEE Transactions, 2005. 4
  • 5. Most previous fault prediction approaches were proposed to analyse faultproneness using complexity code metrics and-or change metrics. Classes that exhibit similar evolution profiles, are considered as co-evolved classes, may have interdependencies among them. However, it is not clear how classes with similare evolution behavior are linked with faults. Indeed, evolution studies out there did not link different evolution behavior to faults. How we can relate the evolution of classes in object-oriented programs with fault-proneness. 5
  • 6. In JFreeChart, we find that ChartPanel.java and CombinedDomainXYPlot.java were introduced, changed and renamed in the same versions but in different periods and by different developers. The bugID195003710 reported “ a bug either in ChartPanel or CombinedDomainXYPlot when trying to zoom in/out on the range axis”. 6
  • 7. We classify classes according to their class-profiles. We report three types of class evolution: Short-lived classes: They have a very short lifetime, i.e., they exist only during one version of the program. Persistent classes: They never disappear after their first introduction into the program. Transient classes: They appear and disappear many times during the program lifetime. Co-evolved classes: They have the same evolution profile and are related by static relationships. 7
  • 8. Given several versions of a program, we extracted their class diagrams using an existing tool PADL [3]. We identified class renamings, class changes, and fault fixing using two previous approaches: ADvISE [4] and Macocha [5]. We created the set of class-profiles that describes the evolution of each class in the program. [3] Y.-G. Guéhéneuc and G. Antoniol, “DeMIMA: A multilayered framework for design pattern identification,” Transactions on Software Engineering (TSE), vol. 34, no. 5, pp. 667–684, 2008. [4] S. Hassaine, Yann-Ga¨el, S. Hamel, and A. Giuliano, “Advise: Architectural decay in software evolution,” in Proc. 16th European Conference on Software Maintenance and Reengineering, 2012. [5] F. Jaafar, Y. Guéhéneuc, S. Hamel, and G. Antoniol, “An exploratory study of macro co-changes,” in Working Conference on Reverse Engineering (WCRE). IEEE, 2011, 8
  • 9. 9
  • 10. RQ1: What is the relation between class lifetime and fault-proneness? We group classes according to their profiles through the program lifespan, by considering the renaming, refactoring, and structural changes of classes, to determine how class lifetime are related to fault-proneness. RQ2 :What is the relation between class co-evolution and fault-proneness? We check if the proportion of faults fixed by maintaining co-evolved classes are significantly more than faults fixed using not co-evolved classes. 10
  • 11. We use Fisher’s exact test and the Chi-Square test to check two hypothesis. We also compute the odds ratio [20] that indicates the likelihood for an event to occur. HRQ10: There is no statistically significant difference between proportions of faults carried by Persistent, Shortlived, and Transient classes in ArgoUML, JFreeChart, and XercesJ. HRQ20: There is no statistically significant difference between proportions of faults involving co-evolved classes or not co-evolved classes in the three programs. 11
  • 12. 12
  • 13. 13
  • 14. 14
  • 15. We found that Persistent classes are significantly less fault-prone than Shortlived and Transient classes. Faults fixed by maintaining co-evolved classes are significantly more than faults fixed using not co-evolved classes. Special attention must be given to these entities to keep the design intact during program evolution because they could have a negative impact on the fault-proneness of the program. 15
  • 16. Relating class lifetime and change-proneness. Using these results to improve faults detection tools. Prevent change in co-evolved classes. Identifying the lifetime followed by classes belonged to design motifs such as design patterns and anti-patterns. 16
  • 17. We provide empirical evidence of the relationships between class evolution and fault proneness. We showed that Persistent classes are significantly less fault-prone than other classes and that faults fixed by maintaining co-evolved classes are significantly more than faults fixed using not co-evolved classes. We provide a basis for future research to understand the causes and the eventual consequences of these findings. 17