Perils of opportunistically reusing software module

Opportunistic reuse is a need based sourcing of software modules without a prior reuse plan. It is a common tactical approach in software development. Developers often reuse an external software module opportunistically to improve their productivity. But, studies have shown that this results in extensive refactoring and adds maintenance owes. We assert this problem to the mismatches between the software under development and the reused external module; caused because of their different assumptions and constraints. We highlight the problems of such opportunistic reuse practices with the help of a case study. In our study, we found issues such as unanticipated behavior, violated constraints, conflict in assumption, fragile structure, and software bloat. In this paper, we like to draw attention of the research community to the wide spread opportunistic reuse practices and the lack of methods to pro‐actively identify and resolve the mismatches. We propose the need for supporting developers in reasoning before reuse from the perspective of identifying and fixing both local and global mismatches. Furthermore, we identify other opportunistic software development practices where similar issues can be observed and also suggest the research areas where further investigation can benefit developers in improving their productivity. Copyright © 2016 John Wiley & Sons, Ltd.

[1]  Edith Schonberg,et al.  Finding low-utility data structures , 2010, PLDI '10.

[2]  William C. Regli,et al.  A Survey of Design Rationale Systems: Approaches, Representation, Capture and Retrieval , 2000, Engineering with Computers.

[3]  David Garlan,et al.  Software architecture: a roadmap , 2000, ICSE '00.

[4]  Cornelia Boldyreff,et al.  Software Reuse in Open Source: A Case Study , 2011, Int. J. Open Source Softw. Process..

[5]  Tsvi Kuflik,et al.  Evaluating software reuse alternatives: a model and its application to an industrial case study , 2004, IEEE Transactions on Software Engineering.

[6]  Jan Bosch,et al.  Documenting after the fact: Recovering architectural design decisions , 2008, J. Syst. Softw..

[7]  Antony Tang,et al.  Software Architecture Design Reasoning: A Case for Improved Methodology Support , 2009, IEEE Software.

[8]  Daniel P. Friedman,et al.  Aspect-Oriented Programming is Quantification and Obliviousness , 2000 .

[9]  Ioannis Stamelos,et al.  Quantifying Reuse in OSS: A Large-Scale Empirical Study , 2014, Int. J. Open Source Softw. Process..

[10]  Sebastian Spaeth,et al.  Code Reuse in Open Source Software , 2008, Manag. Sci..

[11]  Matthew Arnold,et al.  Go with the flow: profiling copies to find runtime bloat , 2009, PLDI '09.

[12]  Barbara G. Ryder,et al.  Blended analysis for performance understanding of framework-based applications , 2007, ISSTA '07.

[13]  Marco Aurélio Gerosa,et al.  More Common Than You Think: An In-depth Study of Casual Contributors , 2016, 2016 IEEE 23rd International Conference on Software Analysis, Evolution, and Reengineering (SANER).

[14]  Philippe Kruchten,et al.  An Ontology of Architectural Design Decisions in Software-Intensive Systems , 2004 .

[15]  Matthew Arnold,et al.  Jolt: lightweight dynamic analysis and removal of object churn , 2008, OOPSLA.

[16]  Arie van Deursen,et al.  Semantic Versioning versus Breaking Changes: A Study of the Maven Repository , 2014, 2014 IEEE 14th International Working Conference on Source Code Analysis and Manipulation.

[17]  A. Mockus,et al.  Large-Scale Code Reuse in Open Source Software , 2007, First International Workshop on Emerging Trends in FLOSS Research and Development (FLOSS'07: ICSE Workshops 2007).

[18]  Nenad Medvidovic,et al.  Toward a Catalogue of Architectural Bad Smells , 2009, QoSA.

[19]  Mario Gleirscher,et al.  On the Extent and Nature of Software Reuse in Open Source Java Projects , 2011, ICSR.

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

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

[22]  Barry Boehm,et al.  Detecting architectural mismatches during systems composition , 1998 .

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

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

[25]  Ann E. Nicholson,et al.  Using Bayesian belief networks for change impact analysis in architecture design , 2007, J. Syst. Softw..

[26]  David Garlan,et al.  Architectural Mismatch: Why Reuse Is Still So Hard , 2009, IEEE Software.

[27]  Joachim Henkel,et al.  Code Reuse in Open Source Software Development: Quantitative Evidence, Drivers, and Impediments , 2010, J. Assoc. Inf. Syst..

[28]  António Rito Silva,et al.  Improving early detection of software merge conflicts , 2012, 2012 34th International Conference on Software Engineering (ICSE).

[29]  William W. Agresti,et al.  Software Reuse: Developers' Experiences and Perceptions , 2011, J. Softw. Eng. Appl..

[30]  Harvey P. Siy,et al.  Parallel changes in large scale software development: an observational case study , 1998, Proceedings of the 20th International Conference on Software Engineering.

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

[32]  Robert DeLine,et al.  Resolving packaging mismatch , 1999 .

[33]  Arie van Deursen,et al.  Measuring software library stability through historical version analysis , 2012, 2012 28th IEEE International Conference on Software Maintenance (ICSM).

[34]  Matthew Arnold,et al.  Software bloat analysis: finding, removing, and preventing performance problems in modern large-scale object-oriented applications , 2010, FoSER '10.

[35]  Andrzej Wasowski,et al.  Forked and integrated variants in an open-source firmware project , 2015, 2015 IEEE International Conference on Software Maintenance and Evolution (ICSME).

[36]  Arie van Deursen,et al.  An exploratory study of the pull-based software development model , 2014, ICSE.

[37]  Jan Bosch,et al.  Software Architecture: The Next Step , 2004, EWSA.

[38]  Ralph E. Johnson,et al.  How do APIs evolve? A story of refactoring , 2006, J. Softw. Maintenance Res. Pract..

[39]  Jens Dietrich,et al.  Broken promises: An empirical study into evolution problems in Java programs caused by library upgrades , 2014, 2014 Software Evolution Week - IEEE Conference on Software Maintenance, Reengineering, and Reverse Engineering (CSMR-WCRE).

[40]  Muhammad Ali Babar,et al.  The Importance of Architectural Knowledge in Integrating Open Source Software , 2011, OSS.

[41]  Sven Apel,et al.  Superimposition: A Language-Independent Approach to Software Composition , 2008, SC@ETAPS.

[42]  Nick Mitchell,et al.  The causes of bloat, the limits of health , 2007, OOPSLA.

[43]  Yuriy Brun,et al.  Proactive detection of collaboration conflicts , 2011, ESEC/FSE '11.