3.3 Creating Reusable Components

Although this research is not concerned in particular with the creation of reusable components,^3.1 because ``anybody who sells a technology for reuse without providing a library of components is a snake oil salesman, a fraud, a charlatan [Zand et al., 1997],'' it is worthwhile to point out the possible venues from which reusable components will come.

As mentioned before, creating reusable components is difficult, time-consuming and expensive, and repositories of components with good quality are rare. Nevertheless, stable progress has been made recently in several directions.

3.3.1 Domain Analysis and Product-Line Analysis

Domain analysis is the identification, analysis, and specification of common requirements from a specific application domain for reuse on multiple projects within that application domain. Domain analysis produces a domain model, which is used as a starting point to construct specifications and designs for many different systems within the application domain [Kang, 1998]. The domain analysis can be either synthetic or evidentiary [Fischer et al., 1995].

The synthetic domain analysis approach resembles the process of developing a single application, but it is more broadly conceived. It starts with an informal description of the application domain, identifies the common features, and develops reusable components corresponding to each feature in the domain.

The evidentiary domain analysis approach starts with existing systems in an application domain, using reverse engineering or design recovery [Ye, 1996] to identify and repackage common components for later reuse.

Product-line analysis is a more comprehensive approach than domain analysis. A product-line is a set of products, already existing or planned to be developed, that share a common set of requirements but also exhibit significant variability in requirements [Griss, 2000]. Product-line analysis differs from domain analysis in that it not only extracts the commonality of the family of systems but also provides a systematic way to treat their significant variability. In addition to common reusable components, product-line analysis often creates a product-line architecture for the family of related systems where reusable components can be plugged in [Batory et al., 2000].

3.3.2 Commercial Off-the-Shelf

Thousands of companies worldwide are developing their own information systems. There are three problems in this regard: (1) because most companies do not have enough expertise in software development, they cannot produce information systems with the highest quality; (2) because these systems are often developed internally and do not follow interoperation standards, it is very difficult to integrate them; and (3) similar functionality has been repeatedly developed. Although it may take decades for it to dominate software development, the market of COTS (Commercial Off-the-Shelf) is rapidly taking shape [Morisio et al., 2000]. COTS comes in a variety of types and levels of software, e.g., components that provide specific functionality (such as subroutines, classes, frameworks, and even complete applications) or tools used to generate code (such as domain-oriented language processors and application generators). Many companies are providing reusable off-the-shelf components for specific domains, and those components can be purchased by developers from the market. As this trend continues, programmers may be able to create their own systems in the future by integrating components from different component vendors. For example, programmers or even end users may create their own word processing applications by integrating components of outline mode, spell-checking, grammar correction, and diagram drawing purchased at market in the same way as they purchase standard applications now.

3.3.3 Open-Source Components

With the advent of the Open Source movement [DiBona et al., 1999], many developer communities, such as the Gamelan website^3.2and the Giant Java Tree,^3.3 have formed, by which programmers can freely exchange their developed products. Moreover, some high-quality reusable component repositories, such as the Jun library [Aoki et al., 2001], have become open-source too. Traditionally, reusable components are created and maintained by creators who develop those components. Programmers who reuse those components are consumers, and do not directly contribute to the creation and evolution of components. By giving programmers full access to the source code, Open Source breaks down the binary choice of creators and consumers [Fischer, 1998a] so that consumers can directly participate in the maintenance and improvement of reusable components or even derive new components from existing ones. This encourages the natural emergence of reusable components with good quality, following the seeding, evolutionary growth, and reseeding (SER) model [Fischer, 1998b]. The initial creator develops the component (seeding), and the component experiences evolutionary growth when it is reused and modified by many other programmers (or consumers). As those modifications are incorporated back into the original component (reseeding), the quality and reusability of the component will improve. The Open Source development model is particularly promising in pushing reuse to a large scale because programmers working on complimentary projects can each leverage the results of the other freely.