What is software reuse?
Software reuse is a term used for developing the software by using the existing software
components. Some of the components that can be reuse are as follows;
• Source code
• Design and interfaces
• User manuals
• Software Documentation
• Software requirement specifications and many more.
What are stages of reuse-oriented software engineering?
Requirement specification:
First of all, specify the requirements. This will help to decide that we have some existing
software components for the development of software or not.
Component analysis
Helps to decide that which component can be reused where.
Requirement updations / modifications.
If the requirements are changed by the customer, then still existing components are helpful
for reuse or not.
Requirement updations / modifications.
If the requirements are changed by the customer, then still existing components are helpful
for reuse or not.
Reuse System design
If the requirements are changed by the customer, then still existing system designs are
helpful for reuse or not.
Development
Existing components are matching with new software or not.
Integration
Can we integrate the new systems with existing components?
System validation
To validate the system that it can be accepted by the customer or not.
Software Reuse Success Factors
1. Capturing Domain Variations
2. Easing Integration
3. Understanding Design Context
4. Effective Teamwork
5. Managing Domain Complexity
What are the advantages of software reuse?
1. Less effort: Software reuse requires less effort because many components use in the
system are ready made components.
2. Time-saving: Re-using the ready made components is time saving for the software
team.
3. Reduce cost: Less effort, and time saving leads to the overall cost reduction.
4. Increase software productivity: when you are provided with ready made
components, then you can focus on the new components that are not available just
like ready made components.
5. Utilize fewer resources: Software reuse save many sources just like effort, time,
money etc.
6. Leads to a better quality software: Software reuse save our time and we can
consume our more time on maintaining software quality and assurance.
Basic issues in any reuse program
The following are some of the basic issues that must be clearly understood for starting any reuse
program.
• Component creation
• Component indexing and storing
• Component search
• Component understanding
• Component adaptation
• Repository maintenance
Component creation- For component creation, the reusable components have to be first
identified. Selection of the right kind of components having potential for reuse is important.
Domain analysis is a promising technique which can be used to create reusable components.
Component indexing and storing- Indexing requires classification of the reusable components
so that they can be easily searched when looking for a component for reuse. The components
need to be stored in a Relational Database Management System (RDBMS) or an Object-Oriented
Database System (ODBMS) for efficient access when the number of components becomes large.
Component searching- The programmers need to search for right components matching their
requirements in a database of components. To be able to search components efficiently, the
programmers require a proper method to describe the components that they are looking for.
Component understanding- The programmers need a precise and sufficiently complete
understanding of what the component does to be able to decide whether they can reuse the
component. To facilitate understanding, the components should be well documented and should
do something simple.
Component adaptation- Often, the components may need adaptation before they can be reused,
since a selected component may not exactly fit the problem at hand. However, tinkering with the
code is also not a satisfactory solution because this is very likely to be a source of bugs.
Repository maintenance- A component repository once is created requires continuous
maintenance. New components, as and when created have to be entered into the repository. The
faulty components have to be tracked. Further, when new applications emerge, the older
applications become obsolete. In this case, the obsolete components might have to be removed
from the repository.