Software Reuse Is A Process Computer Science Essay

Published: Last Edited:

This essay has been submitted by a student. This is not an example of the work written by our professional essay writers.

Software reuse is a process of design and develops software assets, and then reuses these to develop other software products in the future. It consists of two main tasks, develop-for-reuse and develop-by-reuse [1,2]. Develop-for-reuse is a process to produce software assets that able to be adapted in different software products. Develop-by-reuse is a process to adapt and includes an existing software asset in order to develop a new software product [1].

Software reusability is an attribute that refers to the expected reuse potential of a software component. Software reuse not only improves productivity but also has a positive impact on the quality and maintainability of software products. The move toward reuse is becoming so widespread that it has even changed software industry's vocabulary. For example, software acquired externally is described with such terms as commercial-off-the-shelf (COTS) or third-party software, commercially available software (CAS), and non-developmental item (NDI). When used as parts of systems, they are called components, component ware, and so on.

There are good reasons why the industry is moving toward large-scale reuse, including savings in time and money. The cost to develop a new system from scratch is significant. This has made custom software development very expensive. It is generally assumed that the reuse of existing software will enhance the reliability of a new software application. This concept is almost universally accepted because of the obvious fact that a product will work properly if it has already worked before. Some general reusability guidelines include ease of understanding, functional completeness, reliability, good error and exception handling, information hiding, high cohesion and low coupling, portability and modularity [15].

Reuse applies not only to source-code fragments, but to all the intermediate work products generated during the software development, including requirements documentations, specification, design structures, and any information the developer needs to create software [4].

The scope of reuse can vary from the narrowest possible range, namely, from one product version to another, to a wider range such as between two different products within the same line of products or even between products in different product lines [5].

One of famous method of software reuse is what is called white-box reuse; in white box reuse source code of the existing software assets are extracted as components for reuse in another system. This is easiest and cost effective software reuse approach, but the main problem faced in the white box reuse is the process of identifying and extracting the existing components, which is time and effort consuming. Several methods and tools have been proposed and developed in order to overcome this problem. However, the current methods suffer from a lack of integrating process that allows achieving this process completely.

The motivation of this work, is a framework proposed by Anas Bassam et al [1], which support a systematic way of software reuse: build-for-reuse and build-by-reuse. Moreover, the framework follows the Software development process, from Planning, Requirement gathering, Analysis and design, Implementation, and testing to extract a reusable components. Furthermore this extracted components are letter send to components library for storage after passing a reusability test, components in the library are letter extracted for software development by reuse. However, this framework lacks implementation and automatic way of extracting the reusable components.

This work attempts to fill the gap aforementioned gap in the research literature by presenting a tool that extract, categorized reusable components and provide a repository for the component storage; the reusable component library is the repository of the components that are able to use in different systems.

1.2 Problem Statement

White box reuse is considered as the easiest and cost effective reuse approach

It is flexible which can be modified to achieve the new system requirement

However, the main problem faced in the white box is the process of identifying, extracting and categorizing assets found in the existing software system. Several techniques have been proposed in order to overcome these difficulties.

However, the current techniques suffer from lack of integrated technique that allow achieving this process as a one complete process.

This not only increase time for software developers in finding reusable assets but also increase high risk for

Lack of accuracy when identifying and categorization of the assets

Lack of efficiency: This in terms of effort and time for the intended purpose

Discourage the software developers practicing systematic reuse

1.3 Objectives

Develop Prototype that allows

Identifying and Extracting Classes in Object Oriented Source Code

Categorize the extracted classes

Store the classes into repository

1.4 Significance of the study

The Prototype allow to

The repository will increase the probability of using existing software assets

The repository will allow sharing the software assets within the organization or different organization despite their physical location.

1.5 Scope

This project will focus on the class level in java programming language.

2. Literature Review

The notion of reusability has been around since the humans began to solve problems. When we solve a problem, we try to apply the solution to similar new problems. If we find that only some elements of the solution apply, we adapt it to find to fit the new problem. Proven solutions, used over and over to solve the same type of problem, become accepted, generalized, and standardized [4].

Software reuse also follow the same trends since mid and late 1960s when the software community has realized the need, as well as the challenge, for developing systematic software production techniques to improve productivity [6]. The main idea of software reuse is to enhance the quality, increase the productivity, and reduce cost of software development.

What is software reuse?

Software reuse is a process of design and develops of software assets, and then reuse these assets to develop other products in the future. It consists of two main tasks, develop-for-reuse and develop-by-reuse [1-2]. Develop-for reuse is the ability of building application that can be used at all or part of it in other application [1]. Developed - for - reuse is a process of adapting and including existing software assets in order to develop a new software product [2]. Moreover, reuse is not limited specific stage or source-code fragment, but to all the intermediate work products generated during software development, including requirements documents, system specifications, design structures, product component, skills and knowledge, and any information the developer needs to create software [2,4]. However [8], mentioned that reuse approach are commonly categorized under planned reused or opportunistic reuse. Generally, planned reuse refers to the proactive treatment of reuse wherein the organization dedicates upfront planning activities specifically to plan for reuse - the software process defines what assets are to be reused and how to adapt them. On the other hand, opportunity reuse refers to the reactive treatment of reuse that happens only when the opportunity for reuse avails itself.

2.1 General Reusability Attributes

Poulin [3] gives a general guidelines that is shared by most sets of the reusability process

Ease of understanding: The component has thorough documentation, including self-documenting code and in-line comments.

Functional completeness: the components have all the required operations for the current requirement and any reasonable future requirement.

Reliability: The component consistently performs the advertised function without error and passes repeated test across various hardware and operating system.

Good error and exception handling: The most component isolates, documents, and handles errors consistently. It also provides a variety of options for error response.

High cohesion and low coupling: The component does a specific, isolated function with minimal external dependencies.

Portability: The component does not depend on unique hardware or operating system services.

2.2 Types of reusable assets

Anas Al-badareen et al [2] defines different types of software assets that are included in the process. They defined them based on the state of the asset in terms of characteristics, in addition to the location.

Normal Asset (NA): is the asset developed for specific function in certain software products. Normally, this type of asset is conducted during software product development. Therefore, it contains internal software components and allowed to be modified. This asset can be used directly in other software product with or without modification or it can be catalogue first in the repository as it is, whereas an adaptation for ruse is required to be able to be used in different types of software products and it will be defined as a reusable components. Our extracted components will be based on this asset types.

Reusable Asset with Internal Components (RAIC): is a reusable component contains the internal source and allows a modification in order to fit new environments and conditions. Normally, this type of assets is in house development, which it can be developed during software product development, developed independently and stored in the repository, or resulted from modifying a normal assets cataloged in the repository.

Reusable Asset with Market Components (RAMC): is a reusable asset imported from external sources. Therefore, it can be used only as a black box, while any modification required will be conducted on the system components to fit the new component.

Assets Repository: The assets repository is the library of the software assets that developed and imported from different resources in different ways. The repository stores the different versions of the reusable asset, normal assets that we considered in our study, reusable assets with internal components, and reusable assets with market components. The importance of the repository is that categorized and classified reusable assets in a certain way in order to simplify and enhance the process of categorizing, mining, retrieving, and reusing the reusable assets. That will reduce the cost of reuse process and increase the probability of using existing assets as many can.

2.3 Benefit of software reuse

According to Ian Sommerville 2004 [9], software reuse has important benefit to new software development as mentioned below:

Increased dependability

Reused software, that has been tried and tested in working systems, should be m ore dependable than new software. The initial use of the software reveals any design and implementation faults. These are then fixed, thus reducing the number of failures when the software is reused.

Reduced process risk

If software exists, there is less uncertainty in the costs of reusing that software than in the costs of development. This is an important factor for project management as it reduces the margin of error in project cost estimation. This is particularly true when relatively large software components such as sub-systems are reused.

Effective use of specialists

Instead of application specialists doing the same work on different projects, these specialists can develop reusable software that encapsulate their knowledge.


Reused based approaches emphasize cost reduction as a means of increasing productivity.

If software exists, there is less uncertainty in the costs of reusing that software than in the costs of development. This is an important factor for project management as it reduces the margin of error in project cost estimation. This is particularly true when relatively large software components such as sub-systems are reused.

Poulin [3], many believe software reuse provides the key to enormous saving; the US department of defense alone could save 300$ million annually by increasing its level of reuse by 1%.

Accelerated development

Bringing a system to market as early as possible is often more important than overall development costs. Reusing software can speed up system production because both development and validation time should be reduced.

Anas Bassam etal [1] showed that reusability has to be considered, as it is the most significant factor to improve the productivity of the software development.


The process of extraction of reusable component starts from the project planning and match with all of the software development stages. Thus it increases the quality of the reusable components and reduces the effort required to build by reuse software.

Planning phase: in this phase the objective of the reusability is defined. The planning for component extraction identifies which component needed to be extracted, how the process of extraction will be conducted, and when and where the extracted components can be used.

Requirement phase: this is the most important phase in the build for reuse process; in this phase we make a decision of build for reuse. Based on the user requirements the software developers decide which subsystem can be built for reuse. This decision is made when the required component does not exist in the repository/library. Moreover, generality, portability, coherence and coupling are main issues of consideration during the system analysis and design phase after the decision of building reusable components for specific requirement. However, this stage will not very relevant to the current study, as we will consider extracting the reusable component from the end product (source code).

Implementation phase: In this phase the independent subsystem are developed, and the relationship among these subsystem are considered. Moreover, in the test phase the evaluation of each sub-system to work together and produce the expected result is considered. Furthermore, in system documentation, more attention is given to the ability of the sub-system to work and its requirements to perform its goals.

Reusability phase: is the process of evaluation and enhancement of the reusable components according to certain standard. The reusability test consists of formal conditions that are required in the library. The process of the reusable components is conducted till it passes the reusability test. Finally, when the component passes the reusability test, it is saved in the library to be used in other systems.

Mining into source code: The activities of fetching reuse candidates from specific products and copying them into repository is called mining [5]. This is the method that our tool will used to extract a reusable component from source code.

2.5 Reuse Tools

Lack of spending time to determined whether the system components can be reused in similar systems (i.e during current development process) is the main challenges facing approaches such as agile and extreme programming (elaf selim etal [8]). Investigating whether reuse can be achieved by extracting reusable assets from existing applications is therefore very important.

To address this issue, an approach that relies on refactoring and testing practices for extracting reusable assets from existing applications was proposed.

This approach creates reusable APIs in a bottom-up fashion, on demand when a new application might benefit from component in an application. Moreover, the extraction process is guided and supported by the usage examples and testing scenarios in the existing application and new one. However, while this approach extract reusable assets from existing application, it is accompanied by many limitations.

Extracting reusable assets on demand only is not a good practice of software reuse; because we want to speed up development, increase productivity whenever we are developing application by reuse. To search for reusable assets in existing application will take a longer time then expected, however several existing application can be relevant to our current software to develop, to know where to find a reusable assets will be time consuming and required a lot of effort this increase cost and delayed production.

We must know how we can identified a reusable assets in existing application before we can extract them, there is no provision of assets/component identification in this paper.

White-box approach that relies on source code is the most efficient and flexible software reuse, the approach propose here depend on CBD, CBD is not flexible enough because of the limitation that the developers has to modified to suit the current development process, however CBD is a commercially based components.

Lack of provision of storage for extracted reusable asset is another limitation of this paper, this will make it difficult for the developers to store any reusable components for future software development, every time we want to develop new system we have to find relevant system and then extract reusable component.

Another limitation to this approach is that is not universal, as it can only be used in Extreme programming (XP) environment.

Identifying reusable components for software reuse is critical and challenging issue in software due to the different nature of the application requirements even within the same domain [6]. Rapid changes in customer needs and business requirement however might render domain components absolute if these components cannot accommodate changes with minimal cost and effort. Approach in [6] intends to solve this problem by providing a framework for identifying and encapsulating stable domain components. This approach uses formal concept analysis to identify stable domain components with the concept of software stability model (SSM).

However despite the important of this approach in identifying reusable component, emphasis is only given to CBD rather than an open source that is cheaper and flexible.

Provision of storage (repository), However is a key issue to support future reuse, but in this paper no provision of identified component to be stored for retrieval during the new development process. Moreover categorizing identified components is considered as another key issues.

Washizaki et al [7], propose a technique for automatic component extraction from object-oriented programs by refactoring. The techniques "Extract Component" can identify and extract reusable components composed of class from OO programs, and modify the surrounding parts of extracted components in original programs. The method used Class Relation Graph (CRG). The CRG is obtained by a static analysis of the dependencies among java classes/interfaces. Next a clustering algorithm will detect all possible clusters by determining the reachability on the given CRG. The CRG depends on definition 1-7 [7]. After the extraction of the components a refactoring process will modified the parts surrounding the clusters in order to use the newly extracted components so that to avoid the situation where two sets of classes that provide the same function exist in the same organization/library. However, the problem of this method is that it cannot categorize the component extracted and no provision for storage of this components for future reuse.

Storing and retrieving software component for efficient software reuse plays an important role in software reuse process.

Rune Meling et al [11] proposed a framework that allows storing and searching for components from repository. This framework is a new component classification procedure on which component description manager has been design and implemented. The classification framework combines domain knowledge, ontological information and some semantics to allow descriptions of components to be constructed in a consistent and informative way.

However, the problem with above method is its inability to extract components from existing application.

V. Subedha and S. Sridhar [12] proposed a framework for reusing the software components in context level. The framework is design to identify reusable components that exist in the repository specifically those components that have a faulty behavior. Moreover, they proposed Component Extraction scheme named as Minimum Extraction Time First (METF) base on extraction time of the component. This new approach includes the benefits of reuse as reduction in development effort and maintenance effort.

However, this study focused only on the identifying and extracting existing components from repository over network. They dint focused on the process of extracting and categorizing of software component from existing source code, which is more challenging and more important. Moreover, they give also more focused on the frequency of software component reuse.

Other methods in [13,14], suggested a theory for repository construction to support the storage CBD and the process of extracting traceability information from C# projects respectively. However, this methods lack in either extraction, categorization process.

The main motivation of this study is the work presented by Anas Al-badareen et al, called Reusable Software Components Framework. This framework proposes a systematic way of software reuse: build-for-reuse and build-by-reuse. The framework consists of process of extraction evaluation, processing, adoption, and store reusable software component. However this framework lack implementation and automatic way of extracting the reusable components. This study will adapt the frameworks proposed by these authors.

However, all the above-mentioned approaches did not provide a unified method for the reuse component identification, extraction, categorization and storing component for future reuse. Developers required to use many different approach/tool to get a this component, this not only make it had to practice but it is time consuming, high cost, lack of flexibility and platform dependent as each method only address some particular platform not general. Our approach will address this issue by providing a tool to automatically extract, categorized and store reusable software for future software reuse.


3.1 Research Design and Methodology

This research project will be carried out using the design research methodology used in information systems. Design research involves the analysis of the use and the performance of design artifacts to understand, explain and very frequently to improve on the behavior of aspects of information systems (Vaishnavi and Kuechler, 2004).

According to Vaishnavi and Kuechler (2004), the design research methodology contains three major phases: Awareness of the problem, suggestion, development, evaluation and conclusion as shown in figure 3.1 below.

Fig 3.1: The General Methodology of Design Research

3.1. 2 Knowledge flows

Reasoning in the design cycle is a repetitive process, indicated by the knowledge flows, namely circumscription and operation and goal knowledge. The circumscription process explains the knowledge come from the construction of a certain artifact. When in the development or evaluation phase appears that the proposed suggestion does not work, the researcher is forced back to the first process step. The circumscription flow results in valuable constraint knowledge with which the process can start all over again. The second way of knowledge production in the design cycle is through operation and goal knowledge. As cited by Vaishnavi and Kuechler (2004). The conclusion of a research project produces new operation and goal knowledge, which can lead to the awareness of a new problem.

The design researcher learns when things do not work "according to the theory." This happens many times not because of a misunderstanding of the theory, but also the necessarily incomplete nature of any knowledge base. The design process, when interrupted and forced back to Awareness of Problem in this way, contributes valuable constraint knowledge to the understanding of the always-incomplete theories that motivate the original design.

3.1.3. Process steps

As shown in Figure 3.1, the methodology consists of 4 phases namely: Awareness of Problem, Suggestion, Development, Evaluation and Conclusion. Briefly explanation of the phases is introduced in the next sections.

1. Awareness of Problem

The first phase of this method is the understanding of the objectives and the scope of this study, as well as the problems, which are required to be solved. Through discussion and related literature reviews, the awareness of the problem raises because of lack of the tools available for extracting and categorizing of reusable components of java classes. Awareness of problem gives the picture of the problem and some ideas of the problem solving. The problem may come from multiple sources and reading in a connected discipline may also provide the chance to obtain the new findings. The output of this phase is a proposal for a new research effort.

2. Suggestion

The Suggestion phase follows after the Awareness of Problem phase and is closely connected with it. The study suggested the development of a tool for mining and categorizing reusable components will improve the software reusability process. During this step a literature study are carried out. Provide suggestions to identify the requirements for implementing our tool. The literature study embodies a thorough overview of existing methods for extracting of reusable software components. The output of this phase will be our Tentative Design.

3. Development

The Development phase is the implementation of the Tentative Design. The implementation techniques will be different depending on the artifact to be created. The software development and a high level package or tools are required to make an assumption in this phase.

This study used the following languages in coding online guide system:

PHP: Is a programming language originally created for the implementation of dynamic contents in Web pages and runs on the server side. It is free and Open Source software, with developers all over the world. For these reasons it has become one of the most widely Web scripting languages in use (Santos, 2008).

MySQL: The most popular relational database management system for Web applications (Santos, 2008).

Java programming: Is a free and open source programming language developed in 1991 by James Goslin and Patric Naughton at Sun Microsystem. Originally design for programming consumer device, but it was first used to write Internet applet. Java was design to be safe and portable, benefiting both Internet users and students.

4. Evaluation

The fourth phase is the evaluation phase. The tool, which consists of extraction process, classification process and storage, will be evaluate by case study in order to test it efficiency and accuracy in extracting, categorization and storing of reusable components.

5. Conclusion

The last phase consist the consolidation of the results and writing the conclusions. Also, the evaluating of the methods likely result new problem awareness and suggestions for further research.

Expected Result

The final result will be a prototype that

Identify and extract classes in object oriented source code

Categorized the extracted classes

Store the classes into repository

Gant Chart