SEKE 2012 Proceedings - Knowledge Systems Institute

An Exploratory Study of One-Use and Reusable
Software Components
Reghu Anguswamy
Software Reuse Lab
Computer Science, Virginia Tech.
Falls Church, Virginia, USA
reghu@vt.edu
William B. Frakes
Software Reuse Lab
Computer Science, Virginia Tech.
Falls Church, Virginia, USA
frakes@cs.vt.edu
Abstract— One hundred and seven implementations of a one-use
stemmer component and the equivalent reusable programs were
analyzed in this exploratory study. Subjects were given a list of
19 reuse design principles and asked to indicate which ones they
used. A ranking of the design principles by frequency of use is
reported. One-use and the equivalent reusable components were
analyzed using measures of the pairs in terms of size in SLOC
(source lines of code), effort in hours, number of parameters, and
productivity as measured by SLOC/hours to develop. Reusable
components were significantly larger than their equivalent oneuse
components and had significantly more parameters. The
effort required for the reusable components was higher than for
one-use components. The productivity of the developers was
significantly lower for the reusable components compared to the
one-use components.
Keywords: Software reuse, software engineering, empirical
study, reusable component, reuse design principles
I. INTRODUCTION
Many reuse design principles have been proposed [1-4] but
there has been little empirical analysis of their use. The
software reuse literature often refers to a one-use component
and its reusable equivalent, but there has been little study of
this concept. In this study, we examined the reuse design
principles used by one-hundred and one subjects in converting
a one-use s-stemmer component to mak e it reusable. Our
purpose was to conduct an exploratory analysis to identify the
most commonly chosen reuse design principles used to develop
the components and to quantify the differences in size, number
of parameters used and effort between one-use and reusable
components.
Software reuse, the use of existing software artifacts or
knowledge to build new systems, is pursued to realize benefits
such as improved software quality, productivity, or
reliability[5]. Approaches to measuring reuse and reusability
can be found in [6]. Software reuse in industry has been studied
and its benefits analyzed [7-12]. These papers document an
improvement in softw are quality and productivity due to
software reuse. There are also many types of software reuse
[6]. In the paper by Mohagheghi and Conradi [8], it has been
pointed out that althoug h there is positive and significant
evidence for improved productivity, further study is required to
measure the actual gains in productivity. Our paper measures
the effect on productivity of a software developer making a
one-use component reusable.
Component based development in softw are reuse was
presented as early as 1968 by McIlroy [13] suggesting that
interchangeable pieces called software components should
form the basis for software systems. Our study is based on the
component based approach and the reuse design principles
presented in this paper aim at the design and implementation of
simple reusable software components. A software system
developed with reusable components follows a ‘with’ reuse
process while a component designed to be reused in other
systems follows a ‘for’ reuse process.
A. One-use component vs. Reusable component
The distinction between a reusable and its equivalent oneuse
component is an intuitive concept that is not precisely
defined. One-use components are generally written for specific
applications and are not meant to be used again. Reusable
components on the other hand are developed to be used more
than once w ithin a domain or across domains for various
applications in various environments. Reusable components are
generally developed by taking a one-use component and
modifying it either to add more functionality or changing it to
work in other envi ronments following a re-engineering
approach. They can also be developed from scratch. Our study
involves reusable components built by re-engineering one-use
components. It foll ows that compared to equivalent one-use
components; reusable components tend to be larger, more
complex and slower. They also should have more potent ial
input/output types and more parameters.
As a simple example of a one-use versus a reusa ble
component, consider the “hello world” program, hello.c, as
a one-use component and the anymessage.c program as its
reusable equivalent. Here is the code for each:
//hello.c (one-use component)
main(){printf("hello world\n");}
//anymessage.c (reusable component)
main(argc, argv) /* print any message to output */
int argc; char *argv[];
{
int i;
for (i=1; i< argc; i++)
printf("%s ",argv[i]);
printf("\n");
}
194