Enabling Reuse-Based Software Development of Large-Scale Systems

Enabling Reuse-Based SoftwareDevelopment of Large-Scale

Systems

IEEE Transactions on Software Engineering, Volume 31, Issue 6, June 2005

Richard W. Selby, Member, IEEE

FactEnabling 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.

Key PointsEnabling 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.

Abstract/ IntroductionEnabling Reuse-Based Software Development of Large-Scale Systems

In this article, Richard W. Selby analyzes fourclasses of software modules based on the

degreeof modification required for reuse:

Modules w/o revision. Modules w/slight revision (<25% revision). Modules w/major revision (>25% revision). Newly developed modules.


The author also identifies two categories of factors

that characterize successful reuse in large-scale

systems:

Module design factors. Module implementation factors.


Lastly, Selby evaluates the fault rates of the various

types of modules, as well as, discusses the future

research direction for software reuse.

The Software EnvironmentEnabling 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.


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.

Four Objectives/ GoalsEnabling 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.

Goals/ MetricsEnabling 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.


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.


Goal 3 – Characterize software reuse at the module

implementationlevel:

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.


Goal 4 – Characterize software reuse and module faults andchanges:

Module faults; Metric – per source line. Fault correct effort; Metric – same. Module changes; Metric – per source line. Module change effort; Metric – same.

HypothesisEnabling Reuse-Based Software Development of Large-Scale Systems

There is no difference in the characteristics ofsoftware modules reused w/o revision, slightrevision, major revision and newly developed.

Data Collection & Analysis MethodEnabling Reuse-Based Software Development of Large-Scale Systems

The results presented in this paper focus onstatistically significant differences in the

dependantvariables due to the effects of modules origin

(i.e.reuse w/o revision, slight or major revision andnewly developed).

Data Collection & Analysis MethodEnabling 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.

Characterizing Software Reuse at the Project LevelEnabling Reuse-Based Software Development of Large-Scale Systems

Characterizing Software Reuse at the Module Design LevelEnabling Reuse-Based Software Development of Large-Scale Systems

Characterizing Software Reuse at the Module Implementation LevelEnabling Reuse-Based Software Development of Large-Scale Systems

Characterizing Software Reuse and Module Faults and ChangesEnabling Reuse-Based Software Development of Large-Scale Systems

Interpretations & ConclusionsEnabling 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.


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.


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.


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.


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.

QuestionsEnabling Reuse-Based Software Development of Large-Scale Systems

Enabling Reuse-Based Software Development of Large-Scale Systems

Documents

Transcript of Enabling Reuse-Based Software Development of Large-Scale Systems