@proceedings {1919, title = {A Large-Scale Study on the Usage of Testing Patterns that Address Maintainability Attributes}, year = {2017}, note = {"we conducted a large-scale empirical study to measure the application of software testing in the open source community" Our novel approach includes a data set of 82,447 open source projects written in 48 languages The data used in this study include 82,447 open source projects, 251 unit testing frameworks, and 4 unit testing patterns data url: https://goo.gl/Mc7tHk}, month = {05/2017}, pages = {391-401}, abstract = {Test case maintainability is an important concern, especially in open source and distributed development environments where projects typically have high contributor turnover with varying backgrounds and experience, and where code ownership changes often. Similar to design patterns, patterns for unit testing promote maintainability quality attributes such as ease of diagnoses, modifiability, and comprehension. In this paper, we report the results of a large-scale study on the usage of four xUnit testing patterns which can be used to satisfy these maintainability attributes. This is a first-of-its-kind study which developed automated techniques to investigate these issues across 82,447 open source projects, and the findings provide more insight into testing practices in open source projects. Our results indicate that only 17\% of projects had test cases, and from the 251 testing frameworks we studied, 93 of them were being used. We found 24\% of projects with test files implemented patterns that could help with maintainability, while the remaining did not use these patterns. Multiple qualitative analyses indicate that usage of patterns was an ad-hoc decision by individual developers, rather than motivated by the characteristics of the project, and that developers sometimes used alternative techniques to address maintainability concerns.}, keywords = {maintenance, mining software repositories, msr, Unit Test Frameworks, Unit Test Patterns, Unit Testing}, author = {Danielle Gonzalez and Joanna C.S. Santos and Andrew Popovich and Mehdi Mirakhorli and Mei Nagappan} } @conference {951, title = {The evolution of ANT build systems}, booktitle = {2010 7th IEEE Working Conference on Mining Software Repositories (MSR 2010)2010 7th IEEE Working Conference on Mining Software Repositories (MSR 2010)}, year = {2010}, pages = {42 - 51}, publisher = {IEEE}, organization = {IEEE}, address = {Cape Town, South Africa}, abstract = {Build systems are responsible for transforming static source code artifacts into executable software. While build systems play such a crucial role in software development and maintenance, they have been largely ignored by software evolution researchers. With a firm understanding of build system aging processes, project managers could allocate personnel and resources to build system maintenance tasks more effectively, reducing the build maintenance overhead on regular development activities. In this paper, we study the evolution of ANT build systems from two perspectives: (1) a static perspective, where we examine the build system specifications using software metrics adopted from the source code domain; and (2) a dynamic perspective where representative sample build runs are conducted and their output logs are analyzed. Case studies of four open source ANT build systems with a combined history of 152 releases show that not only do ANT build systems evolve, but also that they need to react in an agile manner to changes in the source code.}, keywords = {ant, argouml, build, eclipse, jboss, maintenance, metrics, source code, tomcat}, isbn = {978-1-4244-6802-7}, doi = {10.1109/MSR.2010.5463341}, attachments = {https://flosshub.org/sites/flosshub.org/files/42msr2010_mcintosh.pdf}, author = {McIntosh, Shane and Adams, Bram and Hassan, Ahmed E.} } @conference {Hill:2008:AAM:1370750.1370771, title = {AMAP: automatically mining abbreviation expansions in programs to enhance software maintenance tools}, booktitle = {Proceedings of the 2008 international working conference on Mining software repositories}, series = {MSR {\textquoteright}08}, year = {2008}, month = {05/2008}, pages = {79{\textendash}88}, publisher = {ACM}, organization = {ACM}, address = {New York, NY, USA}, abstract = {When writing software, developers often employ abbreviations in identifier names. In fact, some abbreviations may never occur with the expanded word, or occur more often in the code. However, most existing program comprehension and search tools do little to address the problem of abbreviations, and therefore may miss meaningful pieces of code or relationships between software artifacts. In this paper, we present an automated approach to mining abbreviation expansions from source code to enhance software maintenance tools that utilize natural language information. Our scoped approach uses contextual information at the method, program, and general software level to automatically select the most appropriate expansion for a given abbreviation. We evaluated our approach on a set of 250 potential abbreviations and found that our scoped approach provides a 57\% improvement in accuracy over the current state of the art.}, keywords = {automatic abbreviation expansion, azureus, itext.net, liferay, maintenance, natural language, openoffice.org, program comprehension, source code, tiger envelopes, tools}, isbn = {978-1-60558-024-1}, doi = {http://doi.acm.org/10.1145/1370750.1370771}, url = {http://doi.acm.org/10.1145/1370750.1370771}, attachments = {https://flosshub.org/sites/flosshub.org/files/p79-hill.pdf}, author = {Hill, Emily and Fry, Zachary P. and Boyd, Haley and Sridhara, Giriprasad and Novikova, Yana and Pollock, Lori and Vijay-Shanker, K.} } @conference {Hindle:2008:LCT:1370750.1370773, title = {What do large commits tell us?: a taxonomical study of large commits}, booktitle = {Proceedings of the 2008 international working conference on Mining software repositories}, series = {MSR {\textquoteright}08}, year = {2008}, month = {05/2008}, pages = {99{\textendash}108}, publisher = {ACM}, organization = {ACM}, address = {New York, NY, USA}, abstract = {Research in the mining of software repositories has frequently ignored commits that include a large number of files (we call these large commits). The main goal of this paper is to understand the rationale behind large commits, and if there is anything we can learn from them. To address this goal we performed a case study that included the manual classification of large commits of nine open source projects. The contributions include a taxonomy of large commits, which are grouped according to their intention. We contrast large commits against small commits and show that large commits are more perfective while small commits are more corrective. These large commits provide us with a window on the development practices of maintenance teams.}, keywords = {boost, bug fixing, egroupware, enlightenment, evolution, firebird, large commits, maintenance, mysql, postgresql, samba, software evolution, source control system, spring}, isbn = {978-1-60558-024-1}, doi = {http://doi.acm.org/10.1145/1370750.1370773}, url = {http://doi.acm.org/10.1145/1370750.1370773}, attachments = {https://flosshub.org/sites/flosshub.org/files/p99-hindle.pdf}, author = {Hindle, Abram and Daniel M. German and Holt, Ric} } @conference {1003, title = {Evaluating the Harmfulness of Cloning: A Change Based Experiment}, booktitle = {Fourth International Workshop on Mining Software Repositories (MSR{\textquoteright}07:ICSE Workshops 2007)}, year = {2007}, pages = {18 - 18}, publisher = {IEEE}, organization = {IEEE}, address = {Minneapolis, MN, USA}, abstract = {Cloning is considered a harmful practice for software maintenance because it requires consistent changes of the entities that share a cloned fragment. However this claim has not been refuted or confirmed empirically. Therefore, we have developed a prototype tool, CloneTracker, in order to study the rate of change of applications containing clones. This paper describes CloneTracker and illustrates its preliminary application on a case study.}, keywords = {ccfinder, clone, clones, clonetracker, cloning, ctags, cvs, dnsjava, maintenance, scm, source code}, isbn = {0-7695-2950-X}, doi = {10.1109/MSR.2007.8}, author = {Lozano, Angela and Wermelinger, Michel and Nuseibeh, Bashar} } @conference {1018, title = {Local and Global Recency Weighting Approach to Bug Prediction}, booktitle = {Fourth International Workshop on Mining Software Repositories (MSR{\textquoteright}07:ICSE Workshops 2007)}, year = {2007}, pages = {33 - 33}, publisher = {IEEE}, organization = {IEEE}, address = {Minneapolis, MN, USA}, abstract = {Finding and fixing software bugs is a challenging maintenance task, and a significant amount of effort is invested by software development companies on this issue. In this paper, we use the Eclipse project{\textquoteright}s recorded software bug history to predict occurrence of future bugs. The history contains information on when bugs have been reported and subsequently fixed.}, keywords = {bug fixing, bug reports, eclipse, maintenance, prediction}, isbn = {0-7695-2950-X}, doi = {10.1109/MSR.2007.17}, attachments = {https://flosshub.org/sites/flosshub.org/files/28300033.pdf}, author = {Joshi, Hemant and Zhang, Chuanlei and Ramaswamy, S. and Bayrak, Coskun} } @conference {Jiang:2006:EEC:1137983.1138030, title = {Examining the evolution of code comments in PostgreSQL}, booktitle = {Proceedings of the 2006 international workshop on Mining software repositories}, series = {MSR {\textquoteright}06}, year = {2006}, pages = {179{\textendash}180}, publisher = {ACM}, organization = {ACM}, address = {New York, NY, USA}, abstract = {It is common, especially in large software systems, for developers to change code without updating its associated comments due to their unfamiliarity with the code or due to time constraints. This is a potential problem since outdated comments may confuse or mislead developers who perform future development. Using data recovered from CVS, we study the evolution of code comments in the PostgreSQL project. Our study reveals that over time the percentage of commented functions remains constant except for early fluctuation due to the commenting style of a particular active developer.}, keywords = {code comments, comments, cvs, evolution, functions, maintenance, mining challenge, msr challenge, postgresql, software evolution, software maintenance, source code}, isbn = {1-59593-397-2}, doi = {http://doi.acm.org/10.1145/1137983.1138030}, url = {http://doi.acm.org/10.1145/1137983.1138030}, attachments = {https://flosshub.org/sites/flosshub.org/files/179ExaminingTheEvolution.pdf}, author = {Zhen Ming Jiang and Hassan, Ahmed E.} } @conference {706, title = {Retrieving Open Source Software Licenses}, booktitle = {OSS2006: Open Source Systems (IFIP 2.13)}, series = {IFIP International Federation for Information Processing}, year = {2006}, pages = {35 - 46}, publisher = {Springer}, organization = {Springer}, abstract = {Open Source Software maintenance and reuse require identifying and comprehending the applied software licenses. This paper first characterizes software maintenance, and open source software (OSS) reuse which are particularly relevant in this context. The information needs of maintainers and reusers can be supported by reverse engineering tools at different information retrieval levels. The paper presents an automated license retrieval approach called ASLA. User needs, system architecture, tool features, and tool evaluation are presented. The implemented tool features support identifying source file dependencies and licenses in source files, and adding new license templates for identifying licenses. The tool is evaluated against another tool for license information extraction. ASLA requires the source code as available input but is otherwise not limited to OSS. It supports the same programming languages as GCC. License identification coverage is good and the tool is extendable. }, keywords = {gaim, license, license analysis, maintenance, mozilla, reuse}, doi = {http://dx.doi.org/10.1007/0-387-34226-5_4}, attachments = {https://flosshub.org/sites/flosshub.org/files/Retrieving\%20Open\%20Source\%20Software\%20Licenses.pdf}, author = {Tuunanen, Timo and Koskinen, Jussi and K{\"a}rkk{\"a}inen, Tommi} } @conference {Kim:2005:UCG:1083142.1083146, title = {Using a clone genealogy extractor for understanding and supporting evolution of code clones}, booktitle = {Proceedings of the 2005 international workshop on Mining software repositories}, series = {MSR {\textquoteright}05}, year = {2005}, pages = {17-23}, publisher = {ACM}, organization = {ACM}, address = {New York, NY, USA}, abstract = {Programmers often create similar code snippets or reuse existing code snippets by copying and pasting. Code clones {\textemdash}syntactically and semantically similar code snippets{\textemdash}can cause problems during software maintenance because programmers may need to locate code clones and change them consistently. In this work, we investigate (1) how code clones evolve, (2) how many code clones impose maintenance challenges, and (3) what kind of tool or engineering process would be useful for maintaining code clones. Based on a formal definition of clone evolution, we built a clone genealogy tool that automatically extracts the history of code clones from a source code repository (CVS). Our clone genealogy tool enables several analyses that reveal evolutionary characteristics of code clones. Our initial results suggest that aggressive refactoring may not be the best solution for all code clones; thus, we propose alternative tool solutions that assist in maintaining code clones using clone genealogy information.}, keywords = {clone, clone detection, cvs, developers, evolution, maintenance, refactoring, source code}, isbn = {1-59593-123-6}, doi = {http://doi.acm.org/10.1145/1082983.1083146}, url = {http://doi.acm.org/10.1145/1082983.1083146}, attachments = {https://flosshub.org/sites/flosshub.org/files/17Using.pdf}, author = {Kim, Miryung and Notkin, David} } @conference {1050, title = {Mining version control systems for FACs (frequently applied changes)}, booktitle = {International Workshop on Mining Software Repositories (MSR 2004)}, volume = {2004}, year = {2004}, pages = {48 - 52}, publisher = {IEE}, organization = {IEE}, address = {Edinburgh, Scotland, UK}, abstract = {Today, programmers are forced to maintain a software system based on their gut feeling and experience. This paper makes an attempt to turn the software maintenance craft into a more disciplined activity, by mining for frequently applied changes in a version control system. Next to some initial results, we show how this technique allows to recover and study successful maintenance strategies, adopted for the redesign of long{\textendash}lived systems.}, keywords = {ccfinder, change analysis, change history, clone, clone detection, cvs, maintenance, tomcat, version control}, doi = {10.1049/ic:20040475}, attachments = {https://flosshub.org/sites/flosshub.org/files/48MiningVersion.pdf}, author = {Van Rysselberghe, F. and Demeyer, S} }