Transcript .pptx

Marc Eaddy, Thomas Zimmermann, Kaitlin Sherwood, Vibhav
Garg, Gail Murphy, Nachiappan Nagappan, Alfred Aho
IEEE Transactions on Software Engineering July-Aug. 2008
Reviewed By:
Paul Varcholik
University of Central Florida
[email protected]
EEL 6883 – Software Engineering II
Spring 2009
What is Crosscutting?

Implementation, of a concern, that is scattered
across the program

A concern is any consideration that can impact
the implementation of a program.
 Features from a feature list
 Requirements
 Design patterns and design elements for a UML
design document
 Low-level programming concerns
 Language
 Coding Style
 Algorithms
Research Question
How much does the amount that a
concern is crosscutting affect the
number of defects in a program?
 Hypothesis

The more scattered a concern’s
implementation is, the more defects it will
have, regardless of the implementation size.

Examined through three extensive case
studies
Why Might Crosscutting
Concerns Cause Defects?

A crosscutting concern is:
 Harder to implement and modify
○ Multiple – possibly unrelated – locations in the
code have to be found and updated
simultaneously
 Harder to understand
○ Developers must mentally untangle the code
Why Might Crosscutting
Concerns Cause Defects?
Crosscutting first emerges when the
developer creates – perhaps without
realizing it – a concern implementation
plan.
 Maintainers may proceed without a full
understanding of the scattered nature of
the implementation.

Prior Work
Several empirical studies
 Evidence that crosscutting concerns
degrade code quality because they
negatively impact internal quality metrics

 Program size
 Coupling
 Separation of concerns (modularization)
Additional Terminology

A concern is scattered if it is related to
multiple target elements.

A concern is tangled if both it and at
least one other concern are related to
the same target element.
Model

Concern – an item from a program’s
non-executable specification

Program Elements
 Classes
 Fields
 Methods

Defect – a software bug
Concern Metrics
Bug Count
Number of unique bugs associated with the concern.
Program Element
Contribution (CONT)
Lines of code in the program element associated with the
concern.
Lines of Concern Code
(LOCC)
Total number of LOC that contribute to the implementation of
the concern.
Concern Diffusion over
Components (CDC)
Number of classes that contribute to the implementation of a
concern and other classes and aspects with access them.
Concern Diffusion over
Operations (CDO)
Number of methods which contribute to a concern’s
implementation plus the number of other methods and
advice accessing them.
Degree of Scattering across
Classes (DOSC)
Degree to which the concern code is distributed across
classes (0 to 1).
0 – all code is in one class
1 – codes is equally divided among all classes
Degree of Scattering across
Methods (DOSM)
Degree to which the concern code is distributed across
methods (0 to 1).
Methodology
1.
Reverse Engineer the concern-code
mapping (subjective)
2.
Mine the bug-code mapping
3.
Infer the bug-concern mapping
Case Studies

Mylyn-Bugzilla
 Eclipse plug-in

Rhino
 JavaScipt/ECMAScript interpreter and compiler

iBATIS
 Object-Relational mapping
Spearman Correlation
Coefficients
Range: -1.0 (a perfect negative correlation) to 1.0 (a perfect positive correlation)
Conclusion

All three studies showed a moderate-tostrong correlation between the degree of
scattering and the number of defects.
Concern scattering is correlated with defects.

But does it cause defects? Three criteria for
causality:
1.
2.
3.
Cause must precede the effect
A correlation must exist
The correlation must not be spurious
Strengths
Novel (appears to be first empirical
study to examine crosscutting-defect
correlation)
 Well written
 Solid statistical analysis
 Technically sound methodology
 Simple, but important, hypothesis

Weaknesses
Small study size (3 projects)
 Human analyst for estimating concerncode mapping
 Questionable techniques for identifying
concerns (requirements)
 Some misstatements in the paper
 Do these results generalize? (e.g.
across languages)

Final Thoughts
Study needs to be replicated
 Can defects be reduced by reducing
crosscutting?
 Why does crosscutting occur?

 Programming technology
 Developer aptitude
 Inherent complexity of the concern
Marc Eaddy, Thomas Zimmermann, Kaitlin Sherwood, Vibhav Garg, Gail
Murphy, Nachiappan Nagappan, Alfred Aho
IEEE Transactions on Software Engineering July-Aug. 2008
Reviewed By:
Paul Varcholik
University of Central Florida
[email protected]
EEL 6883 – Software Engineering II
Spring 2009