Technical, cognitive, and social factors inhibit the widespread success of systematic software reuse. Our research is primarily concerned with the cognitive and social challenges faced by software developers: how to motivate them to reuse and how to reduce the difficulty of locating components from a large reuse repository. Our research has explored a new interaction style between software developers and reuse repository systems enabled by information delivery mechanisms. Instead of passively waiting for software developers to explore the reuse repository with explicit queries, information delivery autonomously locates and presents components by using the developers' partially written programs as implicit queries. We have designed

Abstract not found

Although software reuse can improve both the quality and productivity of software development, it will not do so until software developers stop believing that it is not worth their effort to find a component matching their current problem. In addition, if the developers do not anticipate the existence of a given component, they will not even make an effort to find it in the first place. Even the most sophisticated and powerful reuse repositories will not be effective if developers don't anticipate a certain component exists, or don't deem it worthwhile to seek for it. We argue that this crucial barrier to reuse is overcome by integrating active information delivery, which presents information without explicit queries from the user, and reuse repository systems. A prototype system, CodeBroker, illustrates this integration and raises several issues related to software reuse.

Systematic software reuse has emerged as a promising route to improved software development productivity and quality. Many large corporations have initiated systematic reuse programs, and many reuse frameworks have been developed to guide organizations in these efforts. Yet, in spite of this, systematic reuse in practice has been difficult to achieve. In this paper we argue that a key inhibitor has been the incentive conflict inherent in traditional programs of reuse. We reach this conclusion based on an analysis of interview data gathered from 15 projects across eight different sites in a company once viewed as a leader in the reuse movement. We found that one key contributor to the absence of widespread systematic reuse in this firm was a perception among project teams that reuse was incompatible with prevailing project team priorities and incentives, such as to complete projects on time and within budget. Based on this finding, we undertake a survey of different approaches to establishing reuse described in the literature, and analyze them to determine whether incentive incompatibility is inherent in the nature of software reuse for larger organizations. We conclude that it is not, and provide guidance on how such organizations can design an incentive-compatible program of reuse, i.e., one that generates a climate in which developers and teams view reuse as having a more favorable ``value proposition'' according to

Even though component-based software reuse has been shown to increase both the quality and efficiency of software development, there are still major barriers to its wide spread acceptance. Passive and conversational interface-based reuse repository systems support the developer only when he already knows a relevant component exists. In contrast, this paper describes an active and intelligent software agent, CodeBroker, which automates the location of reusable components. CodeBroker runs concurrently in the background of the development environment. Based on the developer's actions, it locates relevant components and delivers them for software developers to reuse. 1 Introduction Component reuse improves both the quality and efficiency of software development [1]. Successful component reuse consists of three phases: locating the reusable components, comprehending them, and finally integrating them into one's current work. Each of these phases is important in its own right and they all ...

Code reuse is a form of knowledge reuse in software development, which is fundamental to innovation in many fields. Yet, to date, there has been no systematic investigation of code reuse in open source software projects. This study uses quantitative and qualitative data gathered from a sample of six open source software projects to explore two sets of research questions derived from the literature on software reuse in firms and open source software development. We find that code reuse is extensive across the sample and that open source software developers, much like developers in firms, apply tools that lower their search costs for knowledge and code, assess the quality of software components, and they have incentives to reuse code. Open source software developers reuse code because they want to integrate functionality quickly, because they want to write preferred code, because they operate under limited resources in terms of time and skills, and because they can mitigate development costs through code reuse.