4.2 Paradigm Shift: From Development-with-Reuse to Reuse-within-Development

4.2.1 Development-with-Reuse

Designers of current component repository systems are not particularly concerned with the problem that programmers make no attempt to reuse because these systems are designed to support the development-with-reuse paradigm [Rada, 1995]. The development-with-reuse paradigm views reuse as a stand-alone process, independent of the current programming process and environment. Consequently, component repository systems are studied as self-contained systems, with no consideration of the context from which the needs for reusable components are derived and the components are reused. Their major focuses have been on the retrieval mechanisms only, with the assumption that programmers have no difficulty in forming reuse intentions and formulating reuse queries. Such systems require programmers to initiate the reuse process by switching from their current development environments to component repository systems with properly formulated reuse queries. Whenever a programming task, either from the original task or as a result of further decomposition, arises, programmers must divert from their current process to execute the reuse process on their own initiative. If they fail to do so, component repository systems are of no use, and reuse will not happen.

Figure 4.2 depicts the development-with-reuse paradigm and its relationship with the overall programming process. At the left side are program development processes and environments, and at the right side are reuse processes and systems. They are separated from each other, and for reuse to succeed, programmers have to bridge the cognitive gap between programming tasks and component repository systems by making an attempt to reuse on their own initiative.

Figure 4.2: The development-with-reuse paradigm

$\parbox{.8\linewidth}{\small{In this paradigm, programmers have to t... ...he initiative to overcome the huge gap between program development and reuse.}}$

4.2.2 Reuse-within-Development

Development-with-reuse is derived from the methodology-centered perspective, which views methodology as the most important thing and requires that programmers adapt their practice to incorporate the new methodology. In contrast, the user-centered perspective--in this case, the programmer-centered perspective--focuses on the behavior of programmers and aims at melding the new development methodology (reuse) into the current practice of programmers [Jarzabek and Huang, 1998].

Development-with-reuse is also a result of the company-centered perspective, which views reuse as a company profitable method, without considering the difficulties encountered by individual programmers [Aaen, 1992]. In contrast, the programmer-centered perspective stresses the importance of offering immediate benefits for programmers. Instead of being driven only by the long-term productivity and quality gains for the company, it attempts to appeal to individual programmers [Winograd, 1995].

Development-with-reuse may work if all programming activities can be planned beforehand. However, as analyzed in Chapter 2, programming is by nature opportunistic: new programming tasks arise all the time during the whole period of programming; so do the reuse opportunities. Reuse cannot be completely planned a priori; it takes place within the context and the process of development [Sen, 1997]. The needs for reusable components cannot be determined in advance, either; instead, they emerge throughout the whole programming process.

In order to put programmers into the center of the design of component repository systems and to put the reuse into the context of programming activities as a whole, a paradigm shift from development-with-reuse to reuse-within-development is needed [Ye, 2001a]. Reuse-within-development views reuse as a supporting, not a replacing, method to the current practice of programmers. It requires that the reuse process be smoothly melded into the current programming process and environment so that there is no context change from programming to reuse. Furthermore, it stresses that reuse should be immediately beneficial to each individual programmer.

To support reuse-within-development, component repository systems should

1. be integrated seamlessly with the programming environment
2. help programmers identify reuse opportunities whenever they arise during their programming processes
3. provide immediate access, from current programming environments, to components potentially reusable in the current development situation so that programmers do not need to switch contexts between programming and reuse