1. Introduction Software is becoming very expensive:
a possible way to reduce cost:
reuse parts from previously made software.
assemble software from off-the-shelf components.

2. Introduction Advantages of reuse also include:
reduced number of defects:
standard and well-tested components are reused.
reduced development time:
provide early market access for products.

3. Software reuse Software development with reuse:
similar to an electronic engineer building an electronic circuit:
uses standard types of electronic ICs and other components.

4. At the most abstract level:
What can be reused?
Specification
Design
Code
Test cases
At the most abstract level:
knowledge

5. Reuse of Knowledge
More difficult compared to day- to-day reuse of knowledge:
developers vary over time and over projects
difficult to remember details of potentially reusable development knowledge.

6. Why almost no software reuse so far?
Engineers working in industry often have a frustrated feeling:
current system is similar to last few systems they have already built
everything is being built from scratch
current system is behind schedule:
no one has time to figure out what this similarity really means.

7. Another complaint
In spite of having software components available for reuse:
programmers have preferred to create their own, because:
available components are difficult to understand
difficult to adapt to new application

8. Basic Issues in Software Reuse
Component creation
Component indexing
Search
Understanding
Adaptation
Repository maintenance

9. Basic Issues Component creation: Component indexing:
Identify reusable components
Component indexing:
classification of reusable components
so that they can be easily searched when we look for a component to reuse.

10. Basic Issues
Search:
search for right components in a database of components
requires a proper method to describe components

11. Basic Issues Understanding:
to decide whether we can use some component
we need a precise and sufficiently complete understanding of what the component does.

12. Basic Issues Adaptation:
A selected component may not exactly fit the problem at hand
Tinkering with the code is not satisfactory:
in any case justified only if thoroughly understood

13. Basic Issues Repository maintenance: component entering
tracking faulty components
new applications emerge
older applications become obsolete
components might need changes
obsolete components might have to be removed

14. Domain analysis
Aim:
identify reusable components for a problem domain.
identification of right kind of reusable information is a difficult problem.

15. Domain analysis Domain analysis identifies:
objects, operations and relationship among them.
Consider airline reservation:
objects are
seats, flights, airports, crew, meal orders
Operations are
scheduling a flight, reserving a seat, assigning a crew to a flight, etc.

16. Domain analysis Analysis of an application domain:
to identify the reusable components
Actual construction of reusable components for a domain
is called domain engineering.

17. Reuse at organization level
Reusability should be a standard part in:
specification, design, implementation, test, etc.
Ideally there is a steady flow of reusable components:
in practice, things are not so simple.

18. Reuse at organization level
Extracting reusable knowledge from past projects:
presents difficulties not encountered in working with a current project
typically original developers are no longer available for consultation.

19. Summary Basic issues in reuse: Component creation Component indexing
Search
Understanding
Adaptation
Repository maintenance

20. Summary Domain analysis:
Creation of highly reusable components is a very difficult problem
a promising approach is domain analysis
Domain analysis:
aims to identify reusable components for a problem domain

21. Summary Application generators:
translate specifications into application programs.
facilitate reuse
not very flexible, if new concepts need to be supported.

22. Summary Reuse at organization level
assess product’s potential for reuse
refine product for greater reusability
integrate product with reuse repository