1 Background

Many people regard the only way to get the benefits from reuse is through systematic reuse programs. One aspect of such programs is the existence of repositories of reusable code -- as Tracz says, ``In order to reuse software, there needs to be software to reuse'' [ Tra95]. One possible inhibitor to acceptance of reuse programs is the cost of the creation and maintenance of repositories of reusable code. Studies have shown that the cost of developing reusable code is typically two times the cost of developing code for single use. Our interest is in reducing the cost of creating reusable code.

2 Position

Our position is that programming environments have not progressed much since the invention of the full-screen editor. Even current so-called ``integrated development environments'' (IDE) only provide a small amount of assistance to a programmer. Anyone who writes code is constantly aware of the wasted effort that it requires. Simple tasks must be frequently repeated (create a new for loop, use the help to remember the key-binding for the if template, look at the documentation for the Layout component, check the Layout documentation again to make sure the argument types are correct, look at a colleague's use of the AccountsPayable framework to see how it is done). All are tasks that could be automated, but typically aren't. Instead IDE's provide tools such as hierarchical browsers (that aren't used) and on-line documentation (that either isn't complete or too difficult to use to easily find what is needed). It is not that this kind of support is bad, it's that it is solving problems that aren't so important while leaving more important problems unsolved. We believe the reason that such environments exist is that they have been developed without a clear idea of what support they are supposed to be providing.

3 Approach and Comparison

In order to support the creation of reusable code, we must first understand what it means for code to be reusable. Our previous work has involved creating a model of how programming languages affect the reusability of code [ BT96]. Our model focuses on units of reuse, which we call assemblies. An assembly is anything that may ultimately become valid source code. Our model describes various aspects of assemblies that are important to our ability to reuse the assemblies. Our model gives the foundations for our investigation into tool support.

Developing with reuse means using existing assemblies when creating new ones. The technical factors associated with developing with reuse can be broken down as follows (adapted from Mili et al. [ MMM95]). If something is to be used, then it first must be identified, thus the cost of the search process affects whether or not reuse takes place. The cost of searching includes the cost of formulating the query and the accuracy of the result, and there is usually a tradeoff between the two. Another part of the identification process is verifying that the assembly is acceptable. Once an acceptable assembly has been identified, it must then be retrieved. When a potential assembly has been identified and retrieved, it must then be adapted to the new environment.

We expect tools to enhance our ability to perform tasks, and we can use the analysis above to identify tasks associated with code reuse that may profit from tool support. There are potentially many tools, even counting only tools with direct support for reuse. McClure [ McC97 ] asserts that there are five types of tools that support the creation and use of a reuse library: repositories, classification tools, browsers, configuration management tools, and cataloguing tools. It should be noted however, that this classification does not cover tools that may be useful for developing for reuse, such as tools for designing, analysing, and testing assemblies.

A critical factor in the design of any tool is simply usability. In particular, Iivari reports that one key reason why CASE tools are generally less successful than had been hoped is the usability of the tools themselves [ Iiv96]. So where tools do support reuse, it is also important that their usability be sufficiently good that programmers actually benefit from the support.

Bibliography

Biographies

Robert Biddle is a faculty member in the Computer Science department of Victoria University of Wellington, New Zealand. He is interested in research on software reusability, programming visualisation, and computer science education. He teaches courses on object-oriented programming, and human-computer interaction. He received a Ph.D. in Computer Science in 1987 from the University of Canterbury; previously he received B.Math and M.Math degrees from the University of Waterloo.