Guest editors introduction: next generation software reuse

Abstract

ncreasing levels of software reuse constitute one of the most pervasive and profound influences in software engineering today. Technological innovations (e.g., objectoriented languages, distributed object models, domain specific languages) and process innovations (e.g., domain modeling, architectural analysis, reuse metrics) are enabling organizations to meet ever-more stringent cost, quality, and interval requirements. Furthermore, there is actually now a reuse market-place: One can literally buy class libraries, frameworks, and components out of catalogues. The Fifth International Conference on Software Reuse that was held in Victoria, B.C., Canada, included papers, mini-workshops, panels, and tutorials dedicated to various aspects of the software reuse enterprise, including objectorientation, domain modeling, domain specific languages, software architecture, and reuse over the internet. Out of the 31 papers (selected from 96 submissions) that were presented, a select few were nominated by the program committee as representing special, innovative contributions. These were subjected a special rereview and two were selected for this special issue. These two papers represent two of the major technological approaches to software reuse: generative/transformational reuse, and object-oriented reuse. The first paper, by Batory, Chen, Robertson, and Wang, considers the problem of selecting the best realizations and algorithms for a general purpose data structure, a container [1]. There are several different implementation choices for such a data structure: linked lists, hash tables, binary trees, etc. Some of these can also be used in conjunction on the same container data structure to provide multiple access modes. Containers can also be concurrent, persistent, secure, and so on. Each of these feature combinations offers specific performance characteristics suitable for specific usage profiles. Selecting the specific combinations of implementation features, given a particular workload, involves the application of specialized design knowledge. The Batory et al. paper describes a framework that encapsulates this design knowledge into a design wizard. This design wizard helps a programmer select a particular combination of container implementation features tailored to a specific application and usage profile. Once a feature set has been selected, code that implements that specific feature combination is generated after applicable optimizations have been performed. As reuse libraries become larger, more feature-rich, and complex, the design choices involved in using them become more difficult; Biggerstaff has called this the “library scaling problem” [4]. The wizard approach of Batory et al. is an important step toward ameliorating this problem. The second paper, by Maruyama and Shima, is concerned with the problem of adapting class libraries for specific requirements. The authors note that OO reuse typically involves two phases: finding a related class, and modifying it to suit the new requirements. They further observe that during the modification phase, developers make heavy use of change precedents: What types of changes have been made before in similar contexts. The modification phase, then, can be viewed as a process of integrating change precedents. They seek to provide automated support for this activity. Changes made to class libraries are stored in change histories. Using their tools involves several steps: Identify a candidate class for adaptation, then identify change precedents, and, finally, integrate change precedents into the candidate class. Their approach is based on [2] and makes use of program slicing, dependence graph, and graph matching. Maruyama and Shima’s work can be viewed as a way to systematically capture and replay typical modifications and extensions that occur during the evolution of object-oriented systems. Some of the early stirrings of software reuse can be traced back to 1958 [1], with the introduction of separate compilation of subroutines in Fortran II, and the increasing use of Fortran subroutine libraries in scientific computation over the following years. There has been dramatic progress since then in languages, component models, transformational techniques, reuse metrics, and processes. The papers in this special section, and those in the Proceedings of the Fifth International Conference of Software Reuse contain important, intriguing ideas that will sustain the progress of software reuse research. We invite you to join in this exciting endeavor.