Systematizing pragmatic software reuse

Many software reuse tasks involve reusing source code that was not designed in a manner conducive to those tasks, requiring that ad hoc modifications be applied. Such pragmatic reuse tasks are a reality in disciplined industrial practice; they arise for a variety of organizational and technical reasons. To investigate a pragmatic reuse task, a developer must navigate through, and reason about, source code dependencies in order to identify program elements that are relevant to the task and to decide how those elements should be reused. The developer must then convert his mental model of the task into a set of actions that he can perform. These steps are poorly supported by modern development tools and practices. We provide a model for the process involved in performing a pragmatic reuse task, including the need to capture (mentally or otherwise) the developer's decisions about how each program element should be treated: this is a pragmatic-reuse plan. We provide partial support for this model via a tool suite, called Gilligan; other parts of the model are supported via standard IDE tools. Using a pragmatic-reuse plan, Gilligan can semiautomatically transform the selected source code from its originating system and integrate it into the developer's system. We have evaluated Gilligan through a series of case studies and experiments (each involving industrial developers) using a variety of source systems and tasks; we report in particular on a previously unpublished, formal experiment. The results show that pragmatic-reuse plans are a robust metaphor for capturing pragmatic reuse intent and that, relative to standard IDE tools, Gilligan can (1) significantly decrease the time that developers require to perform pragmatic reuse tasks, (2) increase the likelihood that developers will successfully complete pragmatic reuse tasks, (3) decrease the time required by developers to identify infeasible reuse tasks, and (4) improve developers' sense of their ability to manage the risk in such tasks.

[1]  Jeffrey S. Poulin,et al.  The Business Case for Software Reuse , 1993, IBM Syst. J..

[2]  R. Fisher.  On the Interpretation of χ2 from Contingency Tables, and the Calculation of P , 2010 .

[3]  Maurizio Morisio,et al.  Success and Failure Factors in Software Reuse , 2002, IEEE Trans. Software Eng..

[4]  Barbara Ann Kitchenham,et al.  Evaluating software engineering methods and tool part 5: the influence of human factors , 1997, SOEN.

[5]  Robert J. Walker,et al.  Lightweight, Semi-automated Enactment of Pragmatic-Reuse Plans , 2008, ICSR.

[6]  M. Engle.  Book Review: Qualitative Data Analysis: An Expanded Sourcebook (2nd Ed.) , 1999 .

[7]  Will Tracz.  Where does reuse start? , 1990, SOEN.

[8]  Elliot Soloway,et al.  Designing documentation to compensate for delocalized plans , 1988, CACM.

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

[10]  Christopher J. Fox,et al.  Sixteen questions about software reuse , 1995, CACM.

[11]  Robert J. Walker,et al.  Approximate Structural Context Matching: An Approach to Recommend Relevant Examples , 2006, IEEE Transactions on Software Engineering.

[12]  Kristen Nygaard,et al.  SIMULA: an ALGOL-based simulation language , 1966, CACM.

[13]  Rainer Koschke,et al.  Locating Features in Source Code , 2003, IEEE Trans. Software Eng..

[14]  C. W. Krueger,et al.  Software product line reuse in practice , 2000, Proceedings 3rd IEEE Symposium on Application-Specific Systems and Software Engineering Technology.

[15]  Martin P. Robillard,et al.  Automatically Recommending Triage Decisions for Pragmatic Reuse Tasks , 2009, 2009 IEEE/ACM International Conference on Automated Software Engineering.

[16]  Martin P. Robillard,et al.  Clone region descriptors: Representing and tracking duplication in source code , 2010, TSEM.

[17]  L. Penrose,et al.  THE CORRELATION BETWEEN RELATIVES ON THE SUPPOSITION OF MENDELIAN INHERITANCE , 2022 .

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

[19]  R. Fisher.  019: On the Interpretation of x2 from Contingency Tables, and the Calculation of P. , 1922 .

[20]  Scott P. Robertson,et al.  Expert problem solving strategies for program comprehension , 1991, CHI.

[21]  Philip J. Guo,et al.  Two studies of opportunistic programming: interleaving web foraging, learning, and writing code , 2009, CHI.

[22]  Steven P. Reiss,et al.  Semantics-based code search , 2009, 2009 IEEE 31st International Conference on Software Engineering.

[23]  Jean-François Rouet,et al.  Documentation as part of design: exploratory field studies , 1995, INTERACT.

[24]  Ben Shneiderman,et al.  Software psychology: Human factors in computer and information systems (Winthrop computer systems series) , 1980 .

[25]  Sushil Krishna Bajracharya,et al.  Applying test-driven code search to the reuse of auxiliary functionality , 2009, SAC '09.

[26]  Cornelius Ncube,et al.  Opportunistic Software Systems Development: Making Systems from What's Available , 2008, IEEE Software.

[27]  Ted J. Biggerstaff,et al.  The library scaling problem and the limits of concrete component reuse , 1994, Proceedings of 1994 3rd International Conference on Software Reuse.

[28]  J. E. Sammet,et al.  Software psychology: human factors in computer and information systems , 1983, SGCH.

[29]  Ruven E. Brooks,et al.  Towards a Theory of the Comprehension of Computer Programs , 1983, Int. J. Man Mach. Stud..

[30]  Martin P. Robillard,et al.  Recommendation Systems for Software Engineering , 2010, IEEE Software.

[31]  David Thomas,et al.  The Pragmatic Programmer: From Journeyman to Master , 1999 .

[32]  Barry W. Boehm,et al.  Managing Software Productivity and Reuse , 1999, Computer.

[33]  Clemens A. Szyperski,et al.  Component software - beyond object-oriented programming , 2002 .

[34]  N. Pennington.  Stimulus structures and mental representations in expert comprehension of computer programs , 1987, Cognitive Psychology.

[35]  Richard W. Selby,et al.  Enabling reuse-based software development of large-scale systems , 2005, IEEE Transactions on Software Engineering.

[36]  Hausi A. Müller,et al.  How do program understanding tools affect how programmers understand programs? , 2000, Sci. Comput. Program..

[37]  Mira Mezini,et al.  Learning from examples to improve code completion systems , 2009, ESEC/SIGSOFT FSE.

[38]  Shinji Kusumoto,et al.  Ranking significance of software components based on use relations , 2003, IEEE Transactions on Software Engineering.

[39]  Miryung Kim,et al.  Program element matching for multi-version program analyses , 2006, MSR '06.

[40]  Slinger Jansen,et al.  Pragmatic and Opportunistic Reuse in Innovative Start-up Companies , 2008, IEEE Software.

[41]  William G. Griswold,et al.  Automated assistance for program restructuring , 1993, TSEM.

[42]  Mik Kersten,et al.  Mylar: a degree-of-interest model for IDEs , 2005, AOSD '05.

[43]  Jeff McAffer,et al.  Eclipse Rich Client Platform , 2010 .

[44]  H. Chernoff,et al.  The Use of Maximum Likelihood Estimates in {\chi^2} Tests for Goodness of Fit , 1954 .

[45]  Glenn S. Fowler,et al.  Ciao: a graphical navigator for software and document repositories , 1995, Proceedings of International Conference on Software Maintenance.

[46]  Matthew B. Miles,et al.  Qualitative Data Analysis: An Expanded Sourcebook , 1994 .

[47]  William F. Opdyke,et al.  Refactoring object-oriented frameworks , 1992 .

[48]  Giovanni Denaro,et al.  ACM Transactions on Software Engineering and Methodology : Volume 22, Nomor 4, 2013 , 2014 .

[49]  Reid Holmes.  Pragmatic software reuse , 2009 .

[50]  Anneliese Amschler Andrews,et al.  Program Comprehension During Software Maintenance and Evolution , 1995, Computer.

[51]  Gail C. Murphy,et al.  Asking and Answering Questions during a Programming Change Task , 2008, IEEE Transactions on Software Engineering.

[52]  Mohamed G. Gouda,et al.  Adaptive Programming , 1991, IEEE Trans. Software Eng..

[53]  A. Strauss,et al.  Grounded theory , 2017 .

[54]  R. Plackett,et al.  Karl Pearson and the Chi-squared Test , 1983 .

[55]  David Lorge Parnas,et al.  On the Design and Development of Program Families , 2001, IEEE Transactions on Software Engineering.

[56]  William B. Frakes,et al.  Software reuse research: status and future , 2005, IEEE Transactions on Software Engineering.

[57]  Martin P. Robillard,et al.  Representing concerns in source code , 2007, TSEM.

[58]  Christopher W. Pidgeon,et al.  DMS®: Program Transformations for Practical Scalable Software Evolution , 2002, IWPSE '02.

[59]  吴树峰.  从学徒到大师之路--读《 The Pragmatic Programmer, From Journeyman to Master》 , 2007 .

[60]  Colin Potts,et al.  Design of Everyday Things , 1988 .

[61]  Mary Beth Rosson,et al.  The reuse of uses in Smalltalk programming , 1996, TCHI.

[62]  Mark D. Semon,et al.  POSTUSE REVIEW: An Introduction to Error Analysis: The Study of Uncertainties in Physical Measurements , 1982 .

[63]  Kate Ehrlich,et al.  Empirical Studies of Programming Knowledge , 1984, IEEE Transactions on Software Engineering.

[64]  Stanley Letovsky,et al.  Cognitive processes in program comprehension , 1986, J. Syst. Softw..

[65]  Hausi A. Müller,et al.  How do program understanding tools affect how programmers understand programs? , 1997, Proceedings of the Fourth Working Conference on Reverse Engineering.

[66]  Jan Bosch,et al.  Design erosion: problems and causes , 2002, J. Syst. Softw..

[67]  E. R. Cohen.  An Introduction to Error Analysis: The Study of Uncertainties in Physical Measurements , 1998 .

[68]  Rubén Prieto-Díaz,et al.  Status report: software reusability , 1993, IEEE Software.

[69]  Rachel K. E. Bellamy,et al.  Using information scent to model the dynamic foraging behavior of programmers in maintenance tasks , 2008, CHI.

[70]  F. Wilcoxon.  Individual Comparisons by Ranking Methods , 1945 .

[71]  Chris Sadler,et al.  Evaluating software engineering methods and tool—part 4: the influence of human factors , 1996, SOEN.

[72]  Robert J. Walker,et al.  Supporting the Investigation and Planning of Pragmatic Reuse Tasks , 2007, 29th International Conference on Software Engineering (ICSE'07).

[73]  Hausi A. Müller,et al.  Rigi: a system for programming-in-the-large , 1988, Proceedings. [1989] 11th International Conference on Software Engineering.

[74]  John A. Mariani,et al.  Software reclamation , 1990, Softw. Eng. J..

[75]  John E. Gaffney,et al.  A general economics model of software reuse , 1992, International Conference on Software Engineering.

[76]  Chad Saunders,et al.  Cognitive heuristics in software engineering applying and extending anchoring and adjustment to artifact reuse , 2004, IEEE Transactions on Software Engineering.

[77]  Gerhard Fischer,et al.  Cognitive View of Reuse and Redesign , 1987, IEEE Software.

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

[79]  James R. Cordy,et al.  The TXL source transformation language , 2006, Sci. Comput. Program..

[80]  Karl Pearson,et al.  Mathematical contributions to the theory of evolution. VIII. On the correlation of characters not quantitatively measurable , 1900, Proceedings of the Royal Society of London.

[81]  Miryung Kim,et al.  An empirical study of code clone genealogies , 2005, ESEC/FSE-13.

[82]  Ralph Johnson,et al.  design patterns elements of reusable object oriented software , 2019 .

[83]  Françoise Détienne,et al.  An empirical study of software reuse by experts in object-oriented design , 1995, INTERACT.

[84]  Robert J. Walker,et al.  Semi-automating small-scale source code reuse via structural correspondence , 2008, SIGSOFT '08/FSE-16.

[85]  David Garlan,et al.  Architectural Mismatch: Why Reuse Is So Hard , 1995, IEEE Softw..

[86]  Alan Snyder.  Encapsulation and inheritance in object-oriented programming languages , 1986, OOPSLA 1986.

[87]  Arun Sen,et al.  The Role of Opportunism in the Software Design Reuse Process , 1997, IEEE Trans. Software Eng..

[88]  Victor R. Basili,et al.  Identifying and qualifying reusable software components , 1991, Computer.

[89]  Radu Vanciu,et al.  Hidden dependencies in software systems , 2010, 2010 IEEE International Conference on Software Maintenance.

[90]  James R. Cordy,et al.  Comprehending reality - practical barriers to industrial adoption of software maintenance automation , 2003, 11th IEEE International Workshop on Program Comprehension, 2003..

[91]  Lionel C. Briand,et al.  Using coupling measurement for impact analysis in object-oriented systems , 1999, Proceedings IEEE International Conference on Software Maintenance - 1999 (ICSM'99). 'Software Maintenance for Business Change' (Cat. No.99CB36360).

[92]  R. Fisher.  XV.—The Correlation between Relatives on the Supposition of Mendelian Inheritance. , 1919, Transactions of the Royal Society of Edinburgh.

[93]  Elliot Soloway,et al.  Mental models and software maintenance , 1986, J. Syst. Softw..

[94]  Andrew Begel,et al.  Managing Duplicated Code with Linked Editing , 2004, 2004 IEEE Symposium on Visual Languages - Human Centric Computing.

[95]  R. Holmes,et al.  Using structural context to recommend source code examples , 2005, Proceedings. 27th International Conference on Software Engineering, 2005. ICSE 2005..

[96]  Martin P. Robillard,et al.  Topology analysis of software dependencies , 2008, TSEM.

[97]  Giuseppe Visaggio,et al.  Extracting Reusable Funtions by Flow Graph-Based Program Slicing , 1997, IEEE Trans. Software Eng..

[98]  Charles W. Krueger,et al.  Software reuse , 1992, CSUR.

[99]  Robert J. Walker,et al.  Task-specific source code dependency investigation , 2007, 2007 4th IEEE International Workshop on Visualizing Software for Understanding and Analysis.

[100]  Marcus A. Rothenberger,et al.  Software reuse strategies and component markets , 2003, CACM.

[101]  Françoise Détienne,et al.  Object-Oriented Program Comprehension: Effect of Expertise, Task and Phase , 2002, Empirical Software Engineering.

[102]  Daniel M. Yellin,et al.  Protocol specifications and component adaptors , 1997, TOPL.

[103]  Michael W. Godfrey,et al.  “Cloning considered harmful” considered harmful: patterns of cloning in software , 2008, Empirical Software Engineering.

[104]  Robert DeLine,et al.  Information Needs in Collocated Software Development Teams , 2007, 29th International Conference on Software Engineering (ICSE'07).

[105]  Thomas G. Moher,et al.  Some strategies of reuse in an object-oriented programming environment , 1989, CHI '89.

[106]  H. B. Mann,et al.  On a Test of Whether one of Two Random Variables is Stochastically Larger than the Other , 1947 .

[107]  Kris De Volder,et al.  Navigating and querying code without getting lost , 2003, AOSD '03.