@conference {931, title = {Evaluating process quality in GNOME based on change request data}, booktitle = {2009 6th IEEE International Working Conference on Mining Software Repositories (MSR)2009 6th IEEE International Working Conference on Mining Software Repositories}, year = {2009}, pages = {95 - 98}, publisher = {IEEE}, organization = {IEEE}, address = {Vancouver, BC, Canada}, abstract = {The lifecycle of defects reports and enhancement requests collected in the Bugzilla database of the GNOME project provides valuable information on the evolution of the change request process and for the assessment of process quality in the GNOME sub projects. We present a quality model for the analysis of quality characteristics that is based on evaluating metrics on the Bugzilla database, and illustrate it with a comparative evaluation for 25 of the largest products within GNOME.}, keywords = {bugzilla, bugzillametrics.org, change analysis, change history, gnome, msr challenge, qmetric}, isbn = {978-1-4244-3493-0}, doi = {10.1109/MSR.2009.5069485}, attachments = {https://flosshub.org/sites/flosshub.org/files/95ProcessQualityInGNOME.pdf}, author = {Schackmann, Holger and Lichter, Horst} } @conference {Sager:2006:DSJ:1137983.1138000, title = {Detecting similar Java classes using tree algorithms}, booktitle = {Proceedings of the 2006 international workshop on Mining software repositories}, series = {MSR {\textquoteright}06}, year = {2006}, pages = {65{\textendash}71}, publisher = {ACM}, organization = {ACM}, address = {New York, NY, USA}, abstract = {Similarity analysis of source code is helpful during development to provide, for instance, better support for code reuse. Consider a development environment that analyzes code while typing and that suggests similar code examples or existing implementations from a source code repository. Mining software repositories by means of similarity measures enables and enforces reusing existing code and reduces the developing effort needed by creating a shared knowledge base of code fragments. In information retrieval similarity measures are often used to find documents similar to a given query document. This paper extends this idea to source code repositories. It introduces our approach to detect similar Java classes in software projects using tree similarity algorithms. We show how our approach allows to find similar Java classes based on an evaluation of three tree-based similarity measures in the context of five user-defined test cases as well as a preliminary software evolution analysis of a medium-sized Java project. Initial results of our technique indicate that it (1) is indeed useful to identify similar Java classes, (2)successfully identifies the ex ante and ex post versions of refactored classes, and (3) provides some interesting insights into within-version and between-version dependencies of classes within a Java project.}, keywords = {change analysis, clones, coogle, eclipse, famix, java, similarity, software evolution, software repositories, source code, tree similarity measures}, isbn = {1-59593-397-2}, doi = {http://doi.acm.org/10.1145/1137983.1138000}, url = {http://doi.acm.org/10.1145/1137983.1138000}, attachments = {https://flosshub.org/sites/flosshub.org/files/65Detecting.pdf}, author = {Sager, Tobias and Bernstein, Abraham and Pinzger, Martin and Kiefer, Christoph} } @conference {Canfora:2006:FGI:1137983.1138009, title = {Fine grained indexing of software repositories to support impact analysis}, booktitle = {Proceedings of the 2006 international workshop on Mining software repositories}, series = {MSR {\textquoteright}06}, year = {2006}, pages = {105{\textendash}111}, publisher = {ACM}, organization = {ACM}, address = {New York, NY, USA}, abstract = {Versioned and bug-tracked software systems provide a huge amount of historical data regarding source code changes and issues management. In this paper we deal with impact analysis of a change request and show that data stored in software repositories are a good descriptor on how past change requests have been resolved. A fine grained analysis method of software repositories is used to index code at different levels of granularity, such as lines of code and source files, with free text contained in software repositories. The method exploits information retrieval algorithms to link the change request description and code entities impacted by similar past change requests. We evaluate such approach on a set of three open-source projects.}, keywords = {argouml, change analysis, Firefox, gedit, impact analysis, mining software repositories, scm, source code, version control}, isbn = {1-59593-397-2}, doi = {http://doi.acm.org/10.1145/1137983.1138009}, url = {http://doi.acm.org/10.1145/1137983.1138009}, attachments = {https://flosshub.org/sites/flosshub.org/files/105FineGrained.pdf}, author = {Canfora, Gerardo and Cerulo, Luigi} } @conference {Askari:2006:ITE:1137983.1138013, title = {Information theoretic evaluation of change prediction models for large-scale software}, booktitle = {Proceedings of the 2006 international workshop on Mining software repositories}, series = {MSR {\textquoteright}06}, year = {2006}, pages = {126{\textendash}132}, publisher = {ACM}, organization = {ACM}, address = {New York, NY, USA}, abstract = {In this paper, we analyze the data extracted from several open source software repositories. We observe that the change data follows a Zipf distribution. Based on the extracted data, we then develop three probabilistic models to predict which files will have changes or bugs. The first model is Maximum Likelihood Estimation (MLE), which simply counts the number of events, i.e., changes or bugs, that happen to each file and normalizes the counts to compute a probability distribution. The second model is Reflexive Exponential Decay (RED) in which we postulate that the predictive rate of modification in a file is incremented by any modification to that file and decays exponentially. The third model is called RED-Co-Change. With each modification to a given file, the RED-Co-Change model not only increments its predictive rate, but also increments the rate for other files that are related to the given file through previous co-changes. We then present an information-theoretic approach to evaluate the performance of different prediction models. In this approach, the closeness of model distribution to the actual unknown probability distribution of the system is measured using cross entropy. We evaluate our prediction models empirically using the proposed information-theoretic approach for six large open source systems. Based on this evaluation, we observe that of our three prediction models, the RED-Co-Change model predicts the distribution that is closest to the actual distribution for all the studied systems.}, keywords = {bugs, change analysis, cvs, evaluation approach, file, freebsd, information theory, kde, koffice, log files, netbsd, openbsd, postgresql, prediction, prediction models, scm, source code}, isbn = {1-59593-397-2}, doi = {http://doi.acm.org/10.1145/1137983.1138013}, url = {http://doi.acm.org/10.1145/1137983.1138013}, attachments = {https://flosshub.org/sites/flosshub.org/files/126InformationTheoretic.pdf}, author = {Askari, Mina and Holt, Ric} } @conference {Zimmermann:2006:MAM:1137983.1138025, title = {Mining additions of method calls in ArgoUML}, booktitle = {Proceedings of the 2006 international workshop on Mining software repositories}, series = {MSR {\textquoteright}06}, year = {2006}, pages = {169{\textendash}170}, publisher = {ACM}, organization = {ACM}, address = {New York, NY, USA}, abstract = {In this paper we refine the classical co-change to the addition of method calls. We use this concept to find usage patterns and to identify cross-cutting concerns for ArgoUML.}, keywords = {argouml, change analysis, eclipse, function calls, mining challenge, msr challenge, pattern, source code, xelopes}, isbn = {1-59593-397-2}, doi = {http://doi.acm.org/10.1145/1137983.1138025}, url = {http://doi.acm.org/10.1145/1137983.1138025}, attachments = {https://flosshub.org/sites/flosshub.org/files/169MiningAdditions.pdf}, author = {Zimmermann, Thomas and Breu, Silvia and Lindig, Christian and Livshits, Benjamin} } @conference {Zimmermann:2006:MVA:1137983.1138001, title = {Mining version archives for co-changed lines}, booktitle = {Proceedings of the 2006 international workshop on Mining software repositories}, series = {MSR {\textquoteright}06}, year = {2006}, pages = {72{\textendash}75}, publisher = {ACM}, organization = {ACM}, address = {New York, NY, USA}, abstract = {Files, classes, or methods have frequently been investigated in recent research on co-change. In this paper, we present a first study at the level of lines. To identify line changes across several versions, we define the annotation graph which captures how lines evolve over time. The annotation graph provides more fine-grained software evolution information such as life cycles of each line and related changes: "Whenever a developer changed line 1 of version.txt she also changed line 25 of Library.java."}, keywords = {change, change analysis, change management, graph, lines of code, source code}, isbn = {1-59593-397-2}, doi = {http://doi.acm.org/10.1145/1137983.1138001}, url = {http://doi.acm.org/10.1145/1137983.1138001}, attachments = {https://flosshub.org/sites/flosshub.org/files/72MiningVersionArchives.pdf}, author = {Zimmermann, Thomas and Kim, Sunghun and Zeller, Andreas and Whitehead,Jr., E. James} } @conference {Knab:2006:PDD:1137983.1138012, title = {Predicting defect densities in source code files with decision tree learners}, booktitle = {Proceedings of the 2006 international workshop on Mining software repositories}, series = {MSR {\textquoteright}06}, year = {2006}, pages = {119{\textendash}125}, publisher = {ACM}, organization = {ACM}, address = {New York, NY, USA}, abstract = {With the advent of open source software repositories the data available for defect prediction in source files increased tremendously. Although traditional statistics turned out to derive reasonable results the sheer amount of data and the problem context of defect prediction demand sophisticated analysis such as provided by current data mining and machine learning techniques.In this work we focus on defect density prediction and present an approach that applies a decision tree learner on evolution data extracted from the Mozilla open source web browser project. The evolution data includes different source code, modification, and defect measures computed from seven recent Mozilla releases. Among the modification measures we also take into account the change coupling, a measure for the number of change-dependencies between source files. The main reason for choosing decision tree learners, instead of for example neural nets, was the goal of finding underlying rules which can be easily interpreted by humans. To find these rules, we set up a number of experiments to test common hypotheses regarding defects in software entities. Our experiments showed, that a simple tree learner can produce good results with various sets of input data.}, keywords = {change analysis, data mining, decision tree learner, defect density, defect prediction, mozilla, prediction, release history, scm, source code, version control}, isbn = {1-59593-397-2}, doi = {http://doi.acm.org/10.1145/1137983.1138012}, url = {http://doi.acm.org/10.1145/1137983.1138012}, attachments = {https://flosshub.org/sites/flosshub.org/files/119Predicting.pdf}, author = {Knab, Patrick and Pinzger, Martin and Bernstein, Abraham} } @conference {Fischer:2005:MED:1083142.1083145, title = {Mining evolution data of a product family}, booktitle = {Proceedings of the 2005 international workshop on Mining software repositories}, series = {MSR {\textquoteright}05}, year = {2005}, pages = {12-16}, publisher = {ACM}, organization = {ACM}, address = {New York, NY, USA}, abstract = {Diversification of software assets through changing requirements impose a constant challenge on the developers and maintainers of large software systems. Recent research has addressed the mining for data in software repositories of single products ranging from fine- to coarse grained analyses. But so far, little attention has been payed to mining data about the evolution of product families. In this work, we study the evolution and commonalities of three variants of the BSD (Berkeley Software Distribution), a large open source operating system. The research questions we tackle are concerned with how to generate high level views of the system discovering and indicating evolutionary highlights. To process the large amount of data, we extended our previously developed approach for storing release history information to support the analysis of product families. In a case study we apply our approach on data from three different code repositories representing about 8.5GB of data and 10 years of active development.}, keywords = {bsd, change analysis, change history, cvs, evolution, freebsd, netbsd, openbsd, release history, source code, text mining}, isbn = {1-59593-123-6}, doi = {http://doi.acm.org/10.1145/1082983.1083145}, url = {http://doi.acm.org/10.1145/1082983.1083145}, attachments = {https://flosshub.org/sites/flosshub.org/files/12MiningEvolution.pdf}, author = {Fischer, Michael and Oberleitner, Johann and Ratzinger, Jacek and Gall, Harald} } @conference {Sliwerski:2005:CIF:1083142.1083147, title = {When do changes induce fixes?}, booktitle = {Proceedings of the 2005 international workshop on Mining software repositories}, series = {MSR {\textquoteright}05}, year = {2005}, pages = {24-28}, publisher = {ACM}, organization = {ACM}, address = {New York, NY, USA}, abstract = {As a software system evolves, programmers make changes that sometimes cause problems. We analyze CVS archives for fix-inducing changes{\textemdash}changes that lead to problems, indicated by fixes. We show how to automatically locate fix-inducing changes by linking a version archive (such as CVS) to a bug database (such as BUGZILLA). In a first investigation of the MOZILLA and ECLIPSE history, it turns out that fix-inducing changes show distinct patterns with respect to their size and the day of week they were applied.}, keywords = {bugzilla, change analysis, cvs, eclipse, evolution, mozilla}, isbn = {1-59593-123-6}, doi = {http://doi.acm.org/10.1145/1082983.1083147}, url = {http://doi.acm.org/10.1145/1082983.1083147}, attachments = {https://flosshub.org/sites/flosshub.org/files/24WhenDoChanges.pdf}, author = {Sliwerski, J and Zimmermann, Thomas and Zeller, Andreas} } @conference {Xinyi04fourinteresting, title = {Four Interesting Ways in Which History Can Teach Us About Software}, booktitle = {Proceedings of the 2004 international workshop on Mining software repositories - MSR {\textquoteright}04}, year = {2004}, month = {05/2004}, pages = {58-62}, abstract = {In this position paper, we outline four kinds of studies that we have undertaken in trying to understand various aspects of a software system{\textquoteright}s evolutionary history. In each instance, the studies have involved detailed examination of real software systems based on {\textquotedblleft}facts{\textquotedblright} extracted from various kinds of source artifact repositories, as well as the development of accompanying tools to aid in the extraction, abstraction, and comprehension processes. We briefly discuss the goals, results, and methodology of each approach.}, keywords = {ant, apache, change analysis, clone, clone detection, cvs, evolution, gcc, growth, kepler, linux, midworld, mycore, postgresql, source code, version control}, attachments = {https://flosshub.org/sites/flosshub.org/files/58FourInterestingWays.pdf}, author = {Michael Godfrey and Xinyi Dong and Cory Kapser and Lijie Zou} } @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} }