Software reuse

Software reuse is the process of creating software systems from existing software rather than building software systems from scratch. This simple yet powerful vision was introduced in 1968. Software reuse has, however, failed to become a standard software engineering practice. In an attempt to understand why, researchers have renewed their interest in software reuse and in the obstacles to implementing it. This paper surveys the different approaches to software reuse found in the research literature. It uses a taxonomy to describe and compare the different approaches and make generalizations about the field of software reuse. The taxonomy characterizes each reuse approach in terms of its reusable artifacts and the way these artifacts are abstracted, selected, specialized, and integrated. Abstraction plays a central role in software reuse. Concise and expressive abstractions are essential if software artifacts are to be effectively reused. The effectiveness of a reuse technique can be evaluated in terms of cognitive distance—an intuitive gauge of the intellectual effort required to use the technique. Cognitive distance is reduced in two ways: (1) Higher level abstractions in a reuse technique reduce the effort required to go from the initial concept of a software system to representations in the reuse technique, and (2) automation reduces the effort required to go from abstractions in a reuse technique to an executable implementation. This survey will help answer the following questions: What is software reuse? Why reuse software? What are the different approaches to reusing software? How effective are the different approaches? What is required to implement a software reuse technology? Why is software reuse difficult? What are the open areas for research in software reuse?

[1]  Will Tracz,et al.  Tutorial: Software Reuse: Emerging Technology , 1988 .

[2]  Jean Ichbiah On The Design of ADA , 1983, IFIP Congress.

[3]  Bernard Lang,et al.  Document structure and modularity in mentor , 1984, SDE 1.

[4]  B. Randell,et al.  Software Engineering: Report of a conference sponsored by the NATO Science Committee, Garmisch, Germany, 7-11 Oct. 1968, Brussels, Scientific Affairs Division, NATO , 1969 .

[5]  Sandra Marcus,et al.  Automating Knowledge Acquisition for Expert Systems , 1988 .

[6]  Dennis M. Volpano,et al.  Software templates , 1985, ICSE '85.

[7]  Noah S. Prywes,et al.  Use of Very High Level Languages and Program Generation by Management Professionals , 1984, IEEE Transactions on Software Engineering.

[8]  Ellis Horowitz,et al.  A survey of Application Generators , 1985, IEEE Software.

[9]  T. Biggerstaff,et al.  Reusability Framework, Assessment, and Directions , 1987, IEEE Software.

[10]  Richard C. Waters,et al.  FORMALIZING REUSABLE SOFTWARE COMPONENTS , 1983 .

[11]  David Garlan,et al.  Synthesizing programming environments from reusable features , 1989 .

[12]  Richard C. Waters,et al.  Automatic programming: myths and prospects , 1988, Computer.

[13]  J. M. Neighbors,et al.  Draco: a method for engineering reusable software systems , 1989 .

[14]  Ted J. Biggerstaff,et al.  Software reusability: vol. 2, applications and experience , 1989 .

[15]  Jacques Loeckx,et al.  The Foundations of Program Verification , 1987 .

[16]  Ted J. Biggerstaff,et al.  Software reusability: vol. 1, concepts and models , 1989 .

[17]  Jon Bentley,et al.  Programming pearls: literate programming , 1986, CACM.

[18]  C. Rich,et al.  Formalizing reusable software components in the programmer's apprentice , 1989 .

[19]  Paul Clements,et al.  Enhancing reusability with information hiding , 1989 .

[20]  Guido Persch Automating the transformational development of software , 1987 .

[21]  Brian W. Kernighan The Unix System and Software Reusability , 1984, IEEE Transactions on Software Engineering.

[22]  N. S. Prywes,et al.  Use of the model equational language and program generator by management professionals , 1989 .

[23]  共立出版株式会社 コンピュータ・サイエンス : ACM computing surveys , 1978 .

[24]  Bertrand Meyer,et al.  Reusability: The Case for Object-Oriented Design , 1987, IEEE Software.

[25]  Gail E. Kaiser Semantics for structure editing environments , 1985 .

[26]  Peter Freeman A Conceptual Analysis of the Draco Approach to Constructing Software Systems , 1987, IEEE Transactions on Software Engineering.

[27]  Joseph A. Goguen,et al.  Principles of parameterized programming , 1989 .

[28]  Charles Richter,et al.  PARIS: a system for reusing partially interpreted schemas , 1987, ICSE '87.

[29]  Thomas E. Cheatham,et al.  Reusability Through Program Transformations , 1984, IEEE Transactions on Software Engineering.

[30]  J. Craig Cleaveland,et al.  Building application generators , 1988, IEEE Software.

[31]  Joseph A. Goguen,et al.  Reusing and Interconnecting Software Components , 1986, Computer.

[32]  David W. Embley,et al.  A knowledge structure for reusing abstract data types , 1987, ICSE '87.

[33]  M. W. Wheeler,et al.  Automatic knowledge acquisition for expert systems , 1990, Proceedings of the 1990 Symposium on Applied Computing.

[34]  Richard C. Waters The Programmer's Apprentice: A Session with KBEmacs , 1985, IEEE Transactions on Software Engineering.

[35]  Thomas A. Standish An Essay on Software Reuse , 1984, IEEE Transactions on Software Engineering.

[36]  Guillermo Arango,et al.  Domain Analysis and Software Systems Modeling , 1991 .

[37]  Frederick Hayes-Roth,et al.  Building expert systems , 1983, Advanced book program.

[38]  M. Shaw Larger scale systems require higher-level abstractions , 1989, IWSSD '89.

[39]  Mary Shaw,et al.  Abstraction Techniques in Modern Programming Languages , 1984, IEEE Software.

[40]  Thomas G. Lane User interface software structures , 1990 .

[41]  L. Latour,et al.  Seer: a graphical retrieval system for reusable Ada software modules , 1988, [Proceedings 1988] The Third International IEEE Conference on Ada Applications and Environments.

[42]  R. Balzer A fifteen-year perspective on automatic programming , 1989 .

[43]  David Garlan,et al.  Melding Software Systems from Reusable Building Blocks , 1987, IEEE Software.

[44]  Ellis Horowitz,et al.  An Expansive View of Reusable Software , 1984, IEEE Transactions on Software Engineering.

[45]  David Garlan,et al.  The role of formal reusable frameworks , 1990, Formal Methods in Software Development.

[46]  R. Prieto-Diaz,et al.  Classification of reusable modules , 1989 .

[47]  Edmond Schonberg,et al.  Reusability of design for large software systems: and experiment with the SETL optimizer , 1989 .

[48]  Will Tracz,et al.  Software reuse - emerging technology , 1988 .

[49]  Peter Freeman,et al.  Classifying Software for Reusability , 1987, IEEE Software.

[50]  Philippe Kruchten,et al.  Software Prototyping using the SETL Programming Language , 1984, IEEE Software.

[51]  Frederick P. Brooks,et al.  No Silver Bullet: Essence and Accidents of Software Engineering , 1987 .

[52]  Fred P. Brooks,et al.  The Mythical Man-Month , 1975, Reliable Software.

[53]  Pamela Zave,et al.  The operational versus the conventional approach to software development , 1984, CACM.

[54]  Boleslaw K. Szymanski,et al.  Real-time software life cycle with the model system , 1986, IEEE Transactions on Software Engineering.

[55]  E. Schmidt,et al.  Lex—a lexical analyzer generator , 1990 .

[56]  John P. McDermott,et al.  Making Expert Systems Explicit (Invited Paper) , 1986, IFIP Congress.

[57]  Leon S. Levy,et al.  A metaprogramming method and its economic justification , 1986, IEEE Transactions on Software Engineering.

[58]  Dennis Volpano,et al.  The templates approach to software reuse , 1989 .

[59]  James M. Neighbors,et al.  The Draco Approach to Constructing Software from Reusable Components , 1984, IEEE Transactions on Software Engineering.

[60]  L. P. Deutsch,et al.  Design reuse and frameworks in the smalltalk-80 system , 1989 .

[61]  Donald Ervin Knuth,et al.  The Art of Computer Programming, 2nd Ed. (Addison-Wesley Series in Computer Science and Information , 1978 .

[62]  David C. Luckham,et al.  An Overview of Anna, a Specification Language for Ada , 1985, IEEE Software.

[63]  John McDermott,et al.  Preliminary steps toward a taxonomy of problem-solving methods , 1993 .

[64]  Robert Balzer,et al.  A 15 Year Perspective on Automatic Programming , 1985, IEEE Transactions on Software Engineering.

[65]  Pamela Zave,et al.  Salient features of an executable specification language and its environment , 1986, IEEE Transactions on Software Engineering.

[66]  Hans H. Kron,et al.  Programming-in-the-Large Versus Programming-in-the-Small , 1975 .

[67]  Thomas Reps,et al.  The synthesizer generator , 1984 .

[68]  Gail E. Kaiser,et al.  Incremental dynamic semantics for language-based programming environments , 1989, TOPL.

[69]  Mary Shaw Heterogeneous design idioms for software architecture , 1991, Proceedings of the Sixth International Workshop on Software Specification and Design.

[70]  Grady Booch,et al.  Book Reviews , 1936, Computer.

[71]  Bertrand Meyer Reusability: the case for object-oriented design , 1989 .

[72]  Peter Freeman,et al.  Tutorial, software reusability , 1987 .

[73]  M. S. Feather,et al.  Reuse in the context of a transformation-based methodology , 1989 .

[74]  Ralf Steinbrüggen,et al.  Program Transformation Systems , 1983, CSUR.

[75]  Barry W. Boehm,et al.  Improving Software Productivity , 1987, Computer.

[76]  Daniel G. Bobrow,et al.  Object-Oriented Programming: Themes and Variations , 1989, AI Mag..

[77]  Rubén Prieto-Díaz,et al.  Module interconnection languages , 1986, J. Syst. Softw..

[78]  Barbara Liskov,et al.  Data Abstraction and Hierarchy , 1987 .

[79]  Karl J. Lieberherr,et al.  Demeter: a case study of software growth through parameterized classes , 1988, Proceedings. [1989] 11th International Conference on Software Engineering.