This Article 
   
 Share 
   
 Bibliographic References 
   
 Add to: 
 
Digg
Furl
Spurl
Blink
Simpy
Google
Del.icio.us
Y!MyWeb
 
 Search 
   
Enabling Reuse-Based Software Development of Large-Scale Systems
June 2005 (vol. 31 no. 6)
pp. 495-510
Software reuse enables developers to leverage past accomplishments and facilitates significant improvements in software productivity and quality. Software reuse catalyzes improvements in productivity by avoiding redevelopment and improvements in quality by incorporating components whose reliability has already been established. This study addresses a pivotal research issue that underlies software reuse—what factors characterize successful software reuse in large-scale systems? The research approach is to investigate, analyze, and evaluate software reuse empirically by mining software repositories from a NASA software development environment that actively reuses software. This software environment successfully follows principles of reuse-based software development in order to achieve an average reuse of 32 percent per project, which is the average amount of software either reused or modified from previous systems. We examine the repositories for 25 software systems ranging from 3,000 to 112,000 source lines from this software environment. We analyze four classes of software modules: modules reused without revision, modules reused with slight revision (< 25 percent revision), modules reused with major revision (\geq25 percent revision), and newly developed modules. We apply nonparametric statistical models to compare numerous development variables across the 2,954 software modules in the systems. We identify two categories of factors that characterize successful reuse-based software development of large-scale systems: module design factors and module implementation factors. We also evaluate the fault rates of the reused, modified, and newly developed modules. The module design factors that characterize module reuse without revision were (after normalization by size in source lines): few calls to other system modules, many calls to utility functions, few input-output parameters, few reads and writes, and many comments. The module implementation factors that characterize module reuse without revision were small size in source lines and (after normalization by size in source lines): low development effort and many assignment statements. The modules reused without revision had the fewest faults, fewest faults per source line, and lowest fault correction effort. The modules reused with major revision had the highest fault correction effort and highest fault isolation effort as well as the most changes, most changes per source line, and highest change correction effort. In conclusion, we outline future research directions that build on these software reuse ideas and strategies.

[1] L.J. Osterweil, “Software Processes are Software Too,” Proc. Ninth Int'l Conf. Software Eng., pp. 2-13, Mar. 1987.
[2] B. Meyer, “Reusability: The Case for Object-Oriented Design,” IEEE Software, vol. 4, no. 2, pp. 50-64, Mar. 1987.
[3] G. Booch, “Object-Oriented Development,” IEEE Trans. Software Eng., vol. 12, no. 2, pp. 211-221, Feb. 1986.
[4] J. Neighbors, “The Draco Approach to Constructing Software from Reusable Components,” IEEE Trans. Software Eng., vol. 10, no. 5, pp. 564-573, Sept. 1984.
[5] R. Conn, “An Overview of the DoD Ada Software Repository,” Dr. Dobbs J., pp. 60-61, 86-91, Feb. 1986.
[6] G.E. Kaiser and D. Garlan, “Melding Software Systems from Reusable Building Blocks,” IEEE Software, vol. 4, no. 4, pp. 17-24, July 1987.
[7] T. Reps, Generating Language-Based Environments. MIT Press, 1983.
[8] A.N. Habermann and D. Notkin, “Gandalf: Software Development Environments,” IEEE Trans. Software Eng., vol. 12, no. 12, Dec. 1986.
[9] A. Goldberg and D. Robson, Smalltalk-80: The Language and Its Implementation. Addison-Wesley, 1983.
[10] J.I. Cannon, “Flavors,” MIT Artificial Intelligence Laboratory, technical report, MIT, Cambridge, Mass., 1980.
[11] D.G. Bobrow and M.J. Stefik, “Loops: An Objected-Oriented Programming System for Interlisp,” technical report, Xerox PARC, Palo Alto, Calif., 1982.
[12] D. Bobrow, K. Kahn, G. Kiczales, L. Masinter, M. Stefik, and F. Zdybel, “CommonLoops: Merging Lisp and Object-Oriented Programming,” Proc. OOPSLA 86: Object Oriented Programming Systems, Languages, and Applications, pp. 17-29, 1986.
[13] J.-H. Hulot, “Ceyx, Version 15:1Une Initiation,” Technical Report no. 44, INRIA, France, 1984.
[14] B. Stroustrup, The C++ Programming Language. Addison-Wesley, 1986.
[15] L. Tesler, “Object Pascal Report,” Structured Language World, 1985.
[16] G. Birstwistle et al., Simula Begin. Berlin: Studentliteratur and Auerbach, 1973.
[17] “Special Issue on Software Reusability,” IEEE Trans. Software Eng., T. Biggerstaff and A. Perlis, eds., vol. 10, no. 5, Sept. 1984.
[18] Proc. Workshop Reusability in Programming, T. Biggerstaff, ed., 1983.
[19] “Special Issue on Software Reusability,” IEEE Software, W. Tracz, ed., vol. 4, no. 4, July 1987.
[20] T. Biggerstaff and A. Perlis, Software Reusability. Addison-Wesley, 1989.
[21] W. Tracz, “Ada Reusability Efforts: A Survey of the State of the Practice,” Proc. Fifth Nat'l Conf. Ada Technology, Mar. 1987.
[22] T. Biggerstaff and C. Richter, “Reusability Framework, Assessment, and Directions,” IEEE Software, vol. 4, no. 2, pp. 41-49, Mar. 1987.
[23] R.W. Selby, “Analyzing Software Reuse at the Project and Module Design Levels,” Proc. First European Software Eng. Conf., pp. 227-235, Sept. 1987.
[24] R.W. Selby, “Empirically Analyzing Software Reuse in a Production Environment,” Software ReuseEmerging Technologies, W. Tracz, ed. Sept. 1988.
[25] R.W. Selby, “Quantitative Studies of Software Reuse,” Software Reusability, T. Biggerstaff and A. Perlis, eds., Addison-Wesley, 1989.
[26] “Software Eng. Laboratory (SEL): Database Organization and User's Guide, Revision 1,” Technical Report no. SEL-81-102, Software Eng. Laboratory, NASA/Goddard Space Flight Center, Greenbelt, Md., July 1983.
[27] “Collected Software Eng. Papers: Vol. 1,” Technical Report no. SEL-82-004, Software Eng. Laboratory, NASA/Goddard Space Flight Center, Greenbelt, Md., July 1982.
[28] V.R. Basili, R.W. Selby, and T.Y. Phillips, “Metric Analysis and Data Validation Across Fortran Projects,” IEEE Trans. Software Eng., vol. 9, no. 6, pp. 652-663, Nov. 1983.
[29] D.M. Weiss and V.R. Basili, “Evaluating Software Development by Analysis of Changes: Some Data from the Software Engineering Laboratory,” IEEE Trans. Software Eng., vol. 11, no. 2, pp. 157-168, Feb. 1985.
[30] D.N. Card, G.T. Page, and F.E. McGarry, “Criteria for Software Modularization,” Proc. Eighth Int'l Conf. Software Eng., pp. 372-377, Aug. 1985.
[31] D.N. Card, V.E. Church, and W.W. Agresti, “An Empirical Study of Software Design Practices,” IEEE Trans. Software Eng., vol. 12, no. 2, pp. 264-271, Feb. 1986.
[32] H. Scheffe, The Analysis of Variance. John Wiley and Sons, 1959.
[33] F.P. Brooks, The Mythical Man-Month. Addison-Wesley, 1975.
[34] C.E. Walston and C.P. Felix, “A Method of Programming Measurement and Estimation,” IBM Systems J., vol. 16, no. 1, pp. 54-73, 1977.
[35] B.W. Boehm, Software Eng. Economics. Prentice-Hall, 1981.
[36] W.D. Brooks, “Software Technology Payoff: Some Statistical Evidence,” J. Systems and Software, vol. 2, pp. 3-9, 1981.
[37] J. Vosburgh, B. Curtis, R. Wolverton, B. Albert, H. Malec, S. Hoben, and Y. Liu, “Productivity Factors and Programming Environments,” Proc. Seventh Int'l Conf. Software Eng., pp. 143-152, 1984.
[38] W.G. Cochran and G.M. Cox, Experimental Designs. John Wiley and Sons, 1950.
[39] T.J. McCabe, “A Complexity Measure,” IEEE Trans. Software Eng., vol. 2, no. 4, pp. 308-320, Dec. 1976.
[40] R.W. Selby and A.A. Porter, “Learning from Examples: Generation and Evaluation of Decision Trees for Software Resource Analysis,” IEEE Trans. Software Eng., vol. 14, no. 12, pp. 1743-1757, Dec. 1988.
[41] A. Tomer, L. Goldin, T. Kuflik, E. Kimchi, and S.R. Schach, “Evaluating Software Reuse Alternatives: A Model and its Application to an Industrial Case Study,” IEEE Trans. Software Eng., vol. 30, no. 9, pp. 601-612, Sept. 2004.
[42] B. Morel and P. Alexander, “SPARTACAS: Automating Component Reuse and Adaptation,” IEEE Trans. Software Eng., vol. 30, no. 9, pp. 587-600, Sept. 2004.
[43] M.A. Rothenberger, K.J. Dooley, U.R. Kulkarni, and N. Nada, “Strategies for Software Reuse: A Principal Component Analysis of Reuse Practices,” IEEE Trans. Software Eng., vol. 29, no. 9, pp. 825-837, Sept. 2003.
[44] T. Menzies and J.S. Di Stefano, “More Success and Failure Factors in Software Reuse,” IEEE Trans. Software Eng., vol. 29, no. 5, pp. 474-477, May 2003.
[45] M. Morisio, M. Ezran, and C. Tully, “Success and Failure Factors in Software Reuse,” IEEE Trans. Software Eng., vol. 28, no. 4, pp. 340-357, Apr. 2002.
[46] G. Succi, L. Benedicenti, and T. Vernazza, “Analysis of the Effects of Software Reuse on Customer Satisfaction in an RPG Environment,” IEEE Trans. Software Eng., vol. 27, no. 5, pp. 473-479, May 2001.
[47] P.T. Devanbu, D.E. Perry, and J.S. Poulin, “Guest Editors Introduction: Next Generation Software Reuse,” IEEE Trans. Software Eng., vol. 26, no. 5, pp. 423-424, May 2000.
[48] F. Lanubile and G. Visaggio, “Extracting Reusable Functions by Flow Graph Based Program Slicing,” IEEE Trans. Software Eng., vol. 23, no. 4, pp. 246-259, Apr. 1997.
[49] A. Sen, “The Role of Opportunism in the Software Design Reuse Process,” IEEE Trans. Software Eng., vol. 23, no. 7, pp. 418-436, July 1997.
[50] G.S. Novak, “Software Reuse by Specialization of Generic Procedures Through Views,” IEEE Trans. Software Eng., vol. 23, no. 7, pp. 401-417, July 1997.
[51] N.Y. Lee and C.R. Litecky, “An Empirical Study of Software Reuse with Special Attention to Ada,” IEEE Trans. Software Eng., vol. 23, no. 9, pp. 537-549, Sept. 1997.
[52] M.J. Harrold and G. Rothermel, “Separate Computation of Alias Information for Reuse,” IEEE Trans. Software Eng., vol. 22, no. 7, pp. 442-460, July 1996.
[53] T. Isakowitz and R.J. Kauffman, “Supporting Search for Reusable Software Objects,” IEEE Trans. Software Eng., vol. 22, no. 6, pp. 407-423, June 1996.
[54] W.B. Frakes and C.J. Fox, “Quality Improvement Using a Software Reuse Failure Modes Model,” IEEE Trans. Software Eng., vol. 22, no. 4, pp. 274-279, Apr. 1996.
[55] V. Rajlich and J.H. Silva, “Evolution and Reuse of Orthogonal Architecture,” IEEE Trans. Software Eng., vol. 22, no. 2, pp. 153-157, Feb. 1996.
[56] V.R. Basili, R.W. Selby, and D.H. Hutchens, “Experimentation in Software Eng.,” IEEE Trans. Software Eng., vol. 12, no. 7, pp. 733-743, July 1986.
[57] G. Bockle, P. Clements, J.D. McGregor, D. Muthig, and K. Schmid, “Calculating ROI for Software Product Lines,” IEEE Software, vol. 21, no. 3, pp. 23-31, May-June 2004.
[58] S. Deelstra, M. Sinnema, J. Nijhuis, and J. Bosch, “COSVAM: A Technique for Assessing Software Variability in Software Product Families,” Proc. 20th IEEE Int'l Conf. Software Maintenance, pp. 458-462, Sept. 2004.
[59] J. Bosch and N. Juristo, “Designing Software Architectures for Usability,” Proc. 25th Int'l Conf. Software Eng., pp. 757-758, May 2003.
[60] J. Bosch, “Architecture-Centric Software Eng.,” Proc. 24th Int'l Conf. Software Eng., pp. 681-682, May 2002.
[61] J. Bosch, “Software Product Lines: Organizational Alternatives,” Proc. 23rd Int'l Conf. Software Eng., pp. 91-100, May 2001.
[62] J. Bosch, “Design and Use of Industrial Software Architectures,” Proc. Conf. Technology of Object-Oriented Languages and Systems, pp. 404-404, June 1999.
[63] H. Gomaa, L. Kerschberg, V. Sugumaran, C. Bosch, and I. Tavakoli, “A Prototype Domain Modeling Environment for Reusable Software Architectures,” Proc. Third Int'l Conf. Software Reuse: Advances in Software Reusability, pp. 74-83, Nov. 1994.
[64] P. Clements, D. Garlan, R. Little, R. Nord, and J. Stafford, “Documenting Software Architectures: Views and Beyond,” Proc. 25th Int'l Conf. Software Eng., pp. 740-741, May 2003.
[65] M. Shaw and P. Clements, “A Field Guide to Boxology: Preliminary Classification of Architectural Styles for Software Systems,” Proc. 21st Ann. Int'l Computer Software and Applications Conf., pp. 6-13, Aug. 1997.
[66] R. Kazman, G. Abowd, L. Bass, and P. Clements, “Scenario-Based Analysis of Software Architecture,” IEEE Software, vol. 13, no. 6, pp. 47-55, Nov. 1996.
[67] J. Coplien, D. Hoffman, and D. Weiss, “Commonality and Variability in Software Engineering,” IEEE Software, vol. 15, no. 6, pp. 37-45, Nov.-Dec. 1998.
[68] J. Klein, B. Price, and D. Weiss, “Industrial-Strength Software Product-Line Engineering,” Proc. 25th Int'l Conf. Software Eng., pp. 751-752, May 2003.
[69] N. Soundarajan and J.O. Hallstrom, “Responsibilities and Rewards: Specifying Design Patterns,” Proc. 26th Int'l Conf. Software Eng., pp. 666-675, May 2004.
[70] J.K.H. Mak, C.S.T. Choy, and D.P.K. Lun, “Precise Modeling of Design Patterns in UML,” Proc. 26th Int'l Conf. Software Eng., pp. 252-261, May 2004.
[71] J. Gustafsson, J. Paakki, L. Nenonen, and A.I. Verkamo, “Architecture-Centric Software Evolution by Software Metrics and Design Patterns,” Proc. Sixth European Conf. Software Maintenance and Re-Eng., pp. 108-115, Mar. 2002.

Index Terms:
Index Terms- Software reuse, software measurement, software metrics, software faults, software changes, mining software repositories, large-scale systems, experimentation, empirical study.
Citation:
Richard W. Selby, "Enabling Reuse-Based Software Development of Large-Scale Systems," IEEE Transactions on Software Engineering, vol. 31, no. 6, pp. 495-510, June 2005, doi:10.1109/TSE.2005.69
Usage of this product signifies your acceptance of the Terms of Use.