1. Enabling Reuse-Based Software Development of Large-Scale Systems IEEE Transactions on Software Engineering, Volume 31, Issue 6, June 2005 Richard W. Selby, Member, IEEE

2. Fact Enabling Reuse-Based Software Development of Large-Scale Systems Software reuse leverages past accomplishments and facilitates significant improvements in: Productivity – avoids re-development. Quality – utilizes proven architectures and incorporates components whose reliability has already been established.

3. Key Points Enabling Reuse-Based Software Development of Large-Scale Systems Contribution – what factors characterize successful software reuse in large-scale systems. Definition - modules refer to subroutines, utility functions, main programs, macros and block data.

4. Abstract/ Introduction Enabling Reuse-Based Software Development of Large-Scale Systems In this article, Richard W. Selby analyzes four classes of software modules based on the degree of modification required for reuse: Modules w/o revision. Modules w/slight revision (<25% revision). Modules w/major revision (>25% revision). Newly developed modules.

5. Abstract/ Introduction Enabling Reuse-Based Software Development of Large-Scale Systems The author also identifies two categories of factors that characterize successful reuse in large-scale systems: Module design factors. Module implementation factors.

6. Abstract/ Introduction Enabling Reuse-Based Software Development of Large-Scale Systems Lastly, Selby evaluates the fault rates of the various types of modules, as well as, discusses the future research direction for software reuse.

7. The Software Environment Enabling Reuse-Based Software Development of Large-Scale Systems NASA - Ground supports software for unmanned spacecraft control. Actively reuses software (32% reused/modified) Mature architectures couples with broad populations of content dependent component implementation. The environments reuse process selects reference architectures and populates them with components that have simple, clearly defined interfaces. Can do this successfully because of the maturity of the problem domain & multi-project horizons.

8. The Software Environment Enabling Reuse-Based Software Development of Large-Scale Systems Research Approach - Data mined NASA’s software repositories: 25 software systems. 2954 modules. 22 – 853 modules per project. 3000 – 112,000 lines of code per project. 5 – 25 months project duration. 4 – 23 persons per project.

9. The Software Environment Enabling Reuse-Based Software Development of Large-Scale Systems

10. Four Objectives/ Goals Enabling Reuse-Based Software Development of Large-Scale Systems To characterize software reuse (i.e. reused, modified & newly developed) at the: Project level. Module design level. Module implementation level. Module faults and changes.

11. Goals/ Metrics Enabling Reuse-Based Software Development of Large-Scale Systems Goal 1 – Characterize software reuse at the project level: Distribution across projects and between large (>20K source lines) vs. small projects compare. Amount of reuse across projects compared to development effort and fault rate. Metric – % no revision, slight, major or new.

12. Goals/ Metrics Enabling Reuse-Based Software Development of Large-Scale Systems Goal 2 – Characterize software reuse at the module design level: Amount of reuse compared in terms of interfaces that the module has with: Other system modules (& vise versa); Metric – module calls per source line and input/output parms per source line. Utility functions; Metric – utility calls per source line. Users; Metric – read/write statements per source line. Documentation describing the functionality of the module; Metric – comments per source line.

13. Goals/ Metrics Enabling Reuse-Based Software Development of Large-Scale Systems Goal 3 – Characterize software reuse at the module implementation level: Size of module, large vs. small (large >140 source lines); Metric – source lines per code. Development effort; Metric – effort per source line. Control flow structure; Metric – cyclomatic complexity per source line. Non-control flow structures; Metric – assignment statements per source line.

14. Goals/ Metrics Enabling Reuse-Based Software Development of Large-Scale Systems Goal 4 – Characterize software reuse and module faults and changes: Module faults; Metric – per source line. Fault correct effort; Metric – same. Module changes; Metric – per source line. Module change effort; Metric – same.

15. Hypothesis Enabling Reuse-Based Software Development of Large-Scale Systems There is no difference in the characteristics of software modules reused w/o revision, slight revision, major revision and newly developed.

16. Data Collection & Analysis Method Enabling Reuse-Based Software Development of Large-Scale Systems The results presented in this paper focus on statistically significant differences in the dependant variables due to the effects of modules origin (i.e. reuse w/o revision, slight or major revision and newly developed).

17. Data Collection & Analysis Method Enabling Reuse-Based Software Development of Large-Scale Systems Outlined metrics needed based on the goals. Collected metric data via the NASA repositories. Validated findings through interviews, crosschecks, reviews by objective internal and external personnel. Data was organized into a relational database to be evaluated by NASA and outside researchers. Developed queries to extract data.

18. Characterizing Software Reuse at the Project Level Enabling Reuse-Based Software Development of Large-Scale Systems

21. Characterizing Software Reuse at the Module Design Level Enabling Reuse-Based Software Development of Large-Scale Systems

23. Characterizing Software Reuse at the Module Implementation Level Enabling Reuse-Based Software Development of Large-Scale Systems

25. Characterizing Software Reuse and Module Faults and Changes Enabling Reuse-Based Software Development of Large-Scale Systems

28. Interpretations & Conclusions Enabling Reuse-Based Software Development of Large-Scale Systems Summary of Findings Conclusion – Hypothesis was INCORRECT! Project level – larger projects had high percent modules reused with major revisions. Module design level – modules reused w/o revision had less interfaces with other modules, simpler interfaces, less interaction with users, and a high ratio of commentary to implementation size.

29. Interpretations & Conclusions Enabling Reuse-Based Software Development of Large-Scale Systems Module design level –modules reused w/o revision (compared to those newly developed) had more interaction with utility functions in terms of utility calls, but a lower percent of development effort spent in design activities. Module implementation level – modules reused w/o revision were smaller in size and had less total development effort.

30. Interpretations & Conclusions Enabling Reuse-Based Software Development of Large-Scale Systems Module implementation level – modules reused w/o revision (compared to those newly developed) had more assignment statements. Module faults and changes – modules reused w/o revision had fewer faults and thus less fault correction effort. Module faults and changes – modules reused w/o revision (compared to those w/major revision) had less fault isolation effort, fewer changes and thus less change correction effort.

31. Interpretations & Conclusions Enabling Reuse-Based Software Development of Large-Scale Systems Interpretations and Future Direction Successful software reuse is achievable & sustainable in large scale systems via right combination of architectures and components. Economic benefits (in productivity & quality) can be realized through systemic application of reuse by applying module design and implementation factors.

32. Interpretations & Conclusions Enabling Reuse-Based Software Development of Large-Scale Systems Interpretations and Future Direction Data collection with mining software repositories can be very fruitful in quantifying relationships, trends and trade-offs. Next steps – analyze more than just reuse of source code.

33. Questions Enabling Reuse-Based Software Development of Large-Scale Systems