@proceedings {1752,
	title = {Why Power Laws? An Explanation from Fine-Grained Code Changes},
	year = {2015},
	note = {"The data used in this section come from four open source Java projects. We used CVSANALY to collect data from their Git repositories."},
	abstract = {Throughout the years, empirical studies have found
power law distributions in various measures across many software
systems. However, surprisingly little is known about how
they are produced. What causes these power law distributions?
We offer an explanation from the perspective of fine-grained
code changes. A model based on preferential attachment and selforganized
criticality is proposed to simulate software evolution.
The experiment shows that the simulation is able to render power
law distributions out of fine-grained code changes, suggesting
preferential attachment and self-organized criticality are the
underlying mechanism causing the power law distributions in
software systems.},
	keywords = {Apache Maven, cvsanaly, eclipse, git, Google Guice, java, jedit, open source},
	url = {https://users.soe.ucsc.edu/~linzhp/msr2015.pdf},
	attachments = {https://flosshub.org/sites/flosshub.org/files/msr2015.pdf},
	author = {Zhongpeng Lin and Jim Whitehead}
}
@proceedings {1512,
	title = {Discovering, Reporting, and Fixing Performance Bugs},
	year = {2013},
	month = {05/2013},
	abstract = {Software performance is critical for how users perceive the quality of software products. Performance bugs---programming errors that cause significant performance degradation---lead to poor user experience and low system throughput. Designing effective techniques to address performance bugs requires a deep understanding of how performance bugs are discovered, reported, and fixed. In this paper, we study how performance bugs are discovered, reported to developers, and fixed by developers, and compare the results with those for non-performance bugs. We study performance and non-performance bugs from three popular code bases: Eclipse JDT, Eclipse SWT, and Mozilla. First, we find little evidence that fixing performance bugs has a higher chance to introduce new functional bugs than fixing non-performance bugs, which implies that developers may not need to be overconcerned about fixing performance bugs. Second, although fixing performance bugs is about as error-prone as fixing nonperformance bugs, fixing performance bugs is more difficult than fixing non-performance bugs, indicating that developers need better tool support for fixing performance bugs and testing performance bug patches. Third, unlike many non-performance bugs, a large percentage of performance bugs are discovered through code reasoning, not through users observing the negative effects of the bugs (e.g., performance degradation) or through profiling. The result suggests that techniques to help developers reason about performance, better test oracles, and better profiling techniques are needed for discovering performance bugs.},
	keywords = {bugs, eclipse, mozilla, performance bugs},
	author = {Adrian Nistor and Tian Jiang and Tan, Lin}
}
@proceedings {1513,
	title = {Improving Bug Localization using Correlations in Crash Reports},
	year = {2013},
	month = {05/2013},
	abstract = {Nowadays, many software organizations rely on automatic problem reporting tools to collect crash reports directly from users{\textquoteright} environments. These crash reports are later grouped together into crash types. Usually, developers prioritize crash types based on the number of crash reports and file bugs for the top crash types. Because a bug can trigger a crash in different usage scenarios, different crash types are sometimes related to a same bug. Two bugs are correlated when the occurrence of one bug causes the other bug to occur. We refer to a group of crash types related to identical or correlated bugs, as a crash correlation group. In this paper, we propose three rules to identify correlated crash types automatically. We also propose an algorithm to locate and rank buggy files using crash correlation groups. Through an empirical study on Firefox and Eclipse, we show that the three rules can identify crash correlation groups with a precision of 100\% and a recall of 90\% for Firefox and a precision of 79\% and a recall of 65\% for Eclipse. On the top three buggy file candidates, the proposed bug localization algorithm achieves a recall of 62\% and a precision of 42\% for Firefox and a recall of 52\% and a precision of 50\% for Eclipse. On the top 10 buggy file candidates, the recall increases to 92\% for Firefox and 90\% for Eclipse. Developers can combine the proposed crash correlation rules with the new bug localization algorithm to identify and fix correlated crash types all together.},
	keywords = {eclipse, Firefox},
	author = {Shaohua Wang and Foutse Khomh and Ying Zou}
}
@proceedings {1515,
	title = {Using Citation Influence to Predict Software Defects},
	year = {2013},
	month = {05/2013},
	abstract = {The software dependency network reflects structure and the developer contribution network reflects process. Previous studies have used social network properties over these networks to predict whether a software component is defect-prone. However, these studies do not consider the strengths of the dependencies in the networks. In our approach, we use a citation influence topic model to determine dependency strengths among components and developers, analyze weak and strong dependencies separately, and apply social network properties to predict defect-prone components. In experiments on Eclipse and NetBeans, our approach has higher accuracy than prior work.},
	keywords = {eclipse, netbeans, social network},
	author = {Wei Hu and Kenny Wong}
}
@proceedings {1497,
	title = {Why So Complicated? Simple Term Filtering and Weighting for Location-Based Bug Report Assignment Recommendation},
	year = {2013},
	month = {05-2013},
	pages = {2-11},
	abstract = {Large software development projects receive many
bug reports and each of these reports needs to be triaged. An
important step in the triage process is the assignment of the
report to a developer. Most previous eorts towards improving
bug report assignment have focused on using an activity-based
approach. We address some of the limitations of activity-based
approaches by proposing a two-phased location-based approach
where bug report assignment recommendations are based on the
predicted location of the bug. The proposed approach utilizes
a noun extraction process on several information sources to
determine bug location information and a simple term weighting
scheme to provide a bug report assignment recommendation.
We found that by using a location-based approach, we achieved
an accuracy of 89.41\% and 59.76\% when recommending five
developers for the Eclipse and Mozilla projects, respectively.},
	keywords = {bug, bug report assignment, eclipse, File Activity Histories, Mining Software Artifacts, mozilla, Named Entity Recognition, POS Filtering},
	url = {http://www.cwu.edu/~janvik/papers/msr2013.pdf},
	attachments = {https://flosshub.org/sites/flosshub.org/files/msr2013.pdf}
}
@article {1396,
	title = {Studying the impact of social interactions on software quality},
	journal = {Empirical Software Engineering},
	year = {2012},
	note = {bug databases},
	abstract = {Correcting software defects accounts for a significant amount of resources in a software project. To make best use of testing efforts, researchers have studied statistical models to predict in which parts of a software system future defects are likely to occur. By studying the mathematical relations between predictor variables used in these models, researchers can form an increased understanding of the important connections between development activities and software quality. Predictor variables used in past top-performing models are largely based on source code-oriented metrics, such as lines of code or number of changes. However, source code is the end product of numerous interlaced and collaborative activities carried out by developers. Traces of such activities can be found in the various repositories used to manage development efforts. In this paper, we develop statistical models to study the impact of social interactions in a software project on software quality. These models use predictor variables based on social information mined from the issue tracking and version control repositories of two large open-source software projects. The results of our case studies demonstrate the impact of metrics from four different dimensions of social interaction on post-release defects. Our findings show that statistical models based on social information have a similar degree of explanatory power as traditional models. Furthermore, our results demonstrate that social information does not substitute, but rather augments traditional source code-based metrics used in defect prediction models.},
	keywords = {bug tracker, eclipse, Firefox, Human Factors, measurement, metrics, software evolution, Software quality assurance},
	issn = {1573-7616},
	doi = {10.1007/s10664-012-9205-0},
	author = {Bettenburg, Nicolas and Hassan, Ahmed E.}
}
@conference {bird2012www,
	title = {Who? What? Where? Examining Distributed Development in Two Large Open Source Projects},
	booktitle = {Proceedings of the Working Conference on Mining Software Repositories},
	year = {2012},
	abstract = {To date, a large body of knowledge has been built up around understanding open source software development. However, there is limited research on examining levels of geographic and organizational distribution within open source software projects, despite many studies examining these same aspects in commercial contexts. We set out to fill this gap in OSS knowledge by manually collecting data for two large, mature, successful projects in an effort to assess how distributed both geographically and organizationally. Both Firefox and Eclipse have been the subject of many studies and are ubiquitous in the areas of software development and internet usage respectively. Further, both receive substantial development contributions from many companies. As such, both are worthy of study in order to understand the development processes that they use, how distributed the projects are, and what, if any, relationship distribution has with quality. To this end, we identified the top contributors that made 95\% of the changes over multiple major releases of Firefox and Eclipse and determined their geographic locations and organizational affiliations. We found that Firefox is very geographically distributed with over a third of its components receiving major contributions from developers on different continents, and that components that are highly distributed have no more defects than those that are not. In contrast, Eclipse is directed and developed largely by one company; with IBM making 96\% of the total commits (49\% coming from one lab in Ottawa, Canada). We further examined the distribution in each project{\textquoteright}s constituent subsystems and report the relationship of pre- and post-release defects with geographic and organizational factors.},
	keywords = {eclipse, Firefox},
	attachments = {https://flosshub.org/sites/flosshub.org/files/bird2012www.pdf},
	author = {Christian Bird and Nachiappan Nagappan}
}
@proceedings {1288,
	title = {An Analysis of Author Contribution Patterns in Eclipse Foundation Project Source Code},
	year = {2011},
	note = {"We conducted an observational study on existing Eclipse projects by extracting author attribution data for Java source code files from git repositories."

"Specifically, we consider entropy of source code by counting the number of lines attributed to each author."},
	month = {10/2011},
	pages = {269-281},
	publisher = {Springer},
	abstract = {Collaborative development is a key tenet of open source software, but if not properly understood and managed, it can become a liability. We examine author contribution data for the newest revision of 251,633 Java source files in 592 Eclipse projects. We use this observational data to analyze collaboration patterns within files, and to explore relationships between file size, author count, and code authorship. We calculate author entropy to characterize the contributions of multiple authors to a given file, with an eye toward understanding the degree of collaboration and the most common interaction patterns.},
	keywords = {COLLABORATION, contribution, eclipse, entropy, java},
	author = {Taylor, Quinn C. and Krein, Jonathan L. and MacLean, Alexander C. and Knutson, Charles D.}
}
@conference {1314,
	title = {Apples vs. oranges?},
	booktitle = {Proceedings of the 8th working conference on Mining software repositories - MSR {\textquoteright}11},
	year = {2011},
	note = {"In this MSR challenge report, we compare the source code of two in- dustrial grade Integrated Development Environments (IDE): Netbeans, developed by Oracle Corporation, and Eclipse, developed by the Eclipse Foundation. In the same spirit as [1], our goal is not to identify how similar or different they are, but to identify differences that, if not taken into consideration, might result in biased, and potentially erroneous conclusions."},
	month = {05/2011},
	pages = {246-249},
	publisher = {ACM Press},
	organization = {ACM Press},
	address = {New York, New York, USA},
	abstract = {We attempt to compare the source code of two Java IDE systems: Netbeans and Eclipse. The result of this experiment shows that many factors, if ignored, could risk a bias in the results, and we posit various observations that should be taken into consideration to minimize such risk.

},
	keywords = {eclipse, netbeans, source code},
	isbn = {9781450305747},
	doi = {10.1145/1985441.1985483},
	author = {Davies, Julius and Daniel M. German}
}
@conference {1313,
	title = {Do comments explain codes adequately?},
	booktitle = {Proceedings of the 8th working conference on Mining software repositories - MSR {\textquoteright}11},
	year = {2011},
	month = {05/2011},
	pages = {242-245},
	publisher = {ACM Press},
	organization = {ACM Press},
	address = {New York, New York, USA},
	abstract = {Comment lines in the software source code include descriptions of codes, usage of codes, copyrights, unused codes, comments, and so on. It is required for comments to explain the content of written code adequately, since the wrong description in the comment may causes further bug and confusion in maintenance.

In this paper, we try to clarify a research question: "In which projects do comments describe the code adequately?" To answer this question, we selected the group 1 of mining challenge and used data obtained from Eclipse and Netbeans. Since it is difficult to answer the above question directly, we define the distance between codes and comments. By utilizing the fault-prone module prediction technique, we can answer the alternative question from the data of two projects. The result shows that Eclipse project has relatively adequate comments.},
	keywords = {comments, eclipse, msr challenge, netbeans, prediction},
	isbn = {9781450305747},
	doi = {10.1145/1985441.1985482},
	author = {Mizuno, Osamu and Hirata, Yukinao}
}
@conference {1304,
	title = {Entering the circle of trust},
	booktitle = {Proceeding of the 8th working conference on Mining software repositories - MSR {\textquoteright}11},
	year = {2011},
	note = {"we started by analyzing 219 projects"
},
	month = {05/2011},
	pages = {133-142},
	publisher = {ACM Press},
	organization = {ACM Press},
	address = {New York, New York, USA},
	abstract = {The success of an open-source project depends to a large degree on the proactive and constructive participation by the developer community. An important role that developers play in a project is that of a code committer. However, code-commit privilege is typically restricted to the core group of a project. In this paper, we study the phenomenon of the induction of external developers as code committers. The trustworthiness of an external developer is one of the key factors that determines the granting of commit privileges. Therefore, we formulate different hypotheses to explain how the trust is established in practice. To investigate our hypotheses, we developed an automated approach based on mining code repositories and bug-tracking systems. We implemented the approach and performed an empirical study, using the Eclipse projects, to test the hypotheses. Our results indicate that, most frequently, developers establish trust and credibility in a project by contributing to the project in a non-committer role. Moreover, the employing organization of a developer is another factor--although a less significant one--that influences trust.},
	keywords = {bug tracking, bug tracking system, commits, committers, core, developers, eclipse, trust},
	isbn = {9781450305747},
	doi = {10.1145/1985441.1985462},
	author = {Mani, Senthil and Sinha, Saurabh and Sinha, Vibha Singhal}
}
@conference {1307,
	title = {How do developers blog?},
	booktitle = {Proceedings of the 8th working conference on Mining software repositories - MSR {\textquoteright}11},
	year = {2011},
	note = {publishing frequency, post structure, word usage, publication patterns, content},
	month = {05/2011},
	pages = {123-132},
	publisher = {ACM Press},
	organization = {ACM Press},
	address = {New York, New York, USA},
	abstract = {We report on an exploratory study, which aims at understanding how software developers use social media compared to conventional development infrastructures. We analyzed the blogging and the committing behavior of 1,100 developers in four large open source communities. We observed that these communities intensively use blogs with one new entry about every 8 hours. A blog entry includes 14 times more words than a commit message. When analyzing the content of the blogs, we found that most popular topics represent high-level concepts such as functional requirements and domain concepts. Source code related topics are covered in less than 15\% of the posts. Our results also show that developers are more likely to blog after corrective engineering and management activities than after forward engineering and re-engineering activities. Our findings call for a hypothesis-driven research to further understand the role of social media in software engineering and integrate it into development processes and tools.},
	keywords = {blog, communication, developer, eclipse, gnome, LDA, postgres, python},
	isbn = {9781450305747},
	doi = {10.1145/1985441.1985461},
	author = {Maalej, Walid and Pagano, Dennis}
}
@conference {1310,
	title = {System compatibility analysis of Eclipse and Netbeans based on bug data},
	booktitle = {Proceedings of the 8th working conference on Mining software repositories - MSR {\textquoteright}11},
	year = {2011},
	month = {05/2011},
	pages = {230-233},
	publisher = {ACM Press},
	organization = {ACM Press},
	address = {Waikiki, Honolulu, HI, USANew York, New York, USA},
	abstract = {Eclipse and Netbeans are two top of the line Integrated Development Environments (IDEs) for Java development. Both of them provide support for a wide variety of development tasks and have a large user base. This paper provides an analysis and comparison for the compatibility and stability of Eclipse and Netbeans on the three most commonly used operating systems, Windows, Linux and Mac OS. Both IDEs are programmed in Java and use a Bugzilla issue tracker to track reported bugs and feature requests. We looked into the Bugzilla repository databases of these two IDEs, which contains the bug records and histories of these two IDEs. We used some basic data mining techniques to analyze some historical statistics of the bug data. Based on the analysis, we try to answer certain stability-comparison oriented questions in the paper, so that users can have a better idea which of these two IDEs is designed better to work on different platforms.

},
	keywords = {bug tracking system, bugzilla, eclipse, ms challenge, netbeans, version history},
	isbn = {9781450305747},
	doi = {10.1145/1985441.1985479},
	author = {Baik, Eilwoo and Devanbu, Premkar and Wang, Xinlei (Oscar)}
}
@conference {Bougie:2011:TUT:1984701.1984707,
	title = {Towards understanding twitter use in software engineering: preliminary findings, ongoing challenges and future questions},
	booktitle = {Proceedings of the 2nd International Workshop on Web 2.0 for Software Engineering},
	series = {Web2SE {\textquoteright}11},
	year = {2011},
	note = {paper d/l from http://www.thechiselgroup.org/publications/content/towards-understanding-twitter-use-software-engineering-preliminary-findings-ong

"From this site, we selected the top 30 individuals for the topics Linux and Eclipse. We chose these two topics based on their potential to expose "tweeters" from a large operating system community as well as an IDE development community. We also decided to investigate a project for which all committers use Twitter. Through a colleague, we were informed that the MXUnit project lists the Twitter user names for all eight of its committers. The MXUnit project [5] is a small, open source ColdFusion test framework that is written as an Eclipse plug-in."},
	pages = {31{\textendash}36},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {There has been some research conducted around the motivation for the use of Twitter and the value brought by micro-blogging tools to individuals and business environments. This paper builds on our understanding of how the phenomenon affects the population which birthed the technology: Software Engineers. We find that the Software Engineering community extensively leverages Twitter{\textquoteright}s capabilities for conversation and information sharing and that use of the tool is notably different between distinct Software Engineering groups. Our work exposes topics for future research and outlines some of the challenges in exploring this type of data.},
	keywords = {eclipse, linux, mxunit, social media, software development, twitter, web 2.0},
	isbn = {978-1-4503-0595-2},
	doi = {10.1145/1984701.1984707},
	url = {http://doi.acm.org/10.1145/1984701.1984707},
	attachments = {https://flosshub.org/sites/flosshub.org/files/WEB2SE2011_0.pdf},
	author = {Bougie, Gargi and Starke, Jamie and Storey, Margaret-Anne and Daniel M. German}
}
@conference {Bougie:2011:TUT:1984701.1984707,
	title = {Towards understanding twitter use in software engineering: preliminary findings, ongoing challenges and future questions},
	booktitle = {Proceedings of the 2nd International Workshop on Web 2.0 for Software Engineering},
	series = {Web2SE {\textquoteright}11},
	year = {2011},
	note = {paper d/l from http://www.thechiselgroup.org/publications/content/towards-understanding-twitter-use-software-engineering-preliminary-findings-ong

"From this site, we selected the top 30 individuals for the topics Linux and Eclipse. We chose these two topics based on their potential to expose "tweeters" from a large operating system community as well as an IDE development community. We also decided to investigate a project for which all committers use Twitter. Through a colleague, we were informed that the MXUnit project lists the Twitter user names for all eight of its committers. The MXUnit project [5] is a small, open source ColdFusion test framework that is written as an Eclipse plug-in."},
	pages = {31{\textendash}36},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {There has been some research conducted around the motivation for the use of Twitter and the value brought by micro-blogging tools to individuals and business environments. This paper builds on our understanding of how the phenomenon affects the population which birthed the technology: Software Engineers. We find that the Software Engineering community extensively leverages Twitter{\textquoteright}s capabilities for conversation and information sharing and that use of the tool is notably different between distinct Software Engineering groups. Our work exposes topics for future research and outlines some of the challenges in exploring this type of data.},
	keywords = {eclipse, linux, mxunit, social media, software development, twitter, web 2.0},
	isbn = {978-1-4503-0595-2},
	doi = {10.1145/1984701.1984707},
	url = {http://doi.acm.org/10.1145/1984701.1984707},
	attachments = {https://flosshub.org/sites/flosshub.org/files/WEB2SE2011.pdf},
	author = {Bougie, Gargi and Starke, Jamie and Storey, Margaret-Anne and Daniel M. German}
}
@conference {960,
	title = {A comparative exploration of FreeBSD bug lifetimes},
	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 = {106 - 109},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Cape Town, South Africa},
	abstract = {In this paper, we explore the viability of mining the basic data provided in bug repositories to predict bug lifetimes. We follow the method of Lucas D. Panjer as described in his paper, Predicting Eclipse Bug Lifetimes. However, in place of Eclipse data, the FreeBSD bug repository is used. We compare the predictive accuracy of five different classification algorithms applied to the two data sets. In addition, we propose future work on whether there is a more informative way of classifying bugs than is considered by current bug tracking systems.},
	keywords = {bug reports, bug tracking, classification, eclipse, msr challenge, prediction},
	isbn = {978-1-4244-6802-7},
	doi = {10.1109/MSR.2010.5463291},
	attachments = {https://flosshub.org/sites/flosshub.org/files/106ChallengeGargi.pdf},
	author = {Bougie, Gargi and Treude, Christoph and Daniel M. German and Storey, Margaret-Anne}
}
@conference {961,
	title = {Do stack traces help developers fix bugs?},
	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 = {118 - 121},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Cape Town, South Africa},
	abstract = {A widely shared belief in the software engineering community is that stack traces are much sought after by developers to support them in debugging. But limited empirical evidence is available to confirm the value of stack traces to developers. In this paper, we seek to provide such evidence by conducting an empirical study on the usage of stack traces by developers from the ECLIPSE project. Our results provide strong evidence to this effect and also throws light on some of the patterns in bug fixing using stack traces. We expect the findings of our study to further emphasize the importance of adding stack traces to bug reports and that in the future, software vendors will provide more support in their products to help general users make such information available when filing bug reports.},
	keywords = {bug fixing, bug report, debugging, eclipse, stack trace},
	isbn = {978-1-4244-6802-7},
	doi = {10.1109/MSR.2010.5463280},
	attachments = {https://flosshub.org/sites/flosshub.org/files/118-10-msr.pdf},
	author = {Schroter, Adrian and Schr{\"o}ter, Adrian and Bettenburg, Nicolas and Premraj, Rahul}
}
@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 {950,
	title = {An extensive comparison of bug prediction approaches},
	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 = {31 - 41},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Cape Town, South Africa},
	abstract = {Reliably predicting software defects is one of software engineering{\textquoteright}s holy grails. Researchers have devised and implemented a plethora of bug prediction approaches varying in terms of accuracy, complexity and the input data they require. However, the absence of an established benchmark makes it hard, if not impossible, to compare approaches. We present a benchmark for defect prediction, in the form of a publicly available data set consisting of several software systems, and provide an extensive comparison of the explanative and predictive power of well-known bug prediction approaches, together with novel approaches we devised. Based on the results, we discuss the performance and stability of the approaches with respect to our benchmark and deduce a number of insights on bug prediction models.},
	keywords = {apache, bug reports, eclipse, famix, lucene, mylyn, prediction, scm},
	isbn = {978-1-4244-6802-7},
	doi = {10.1109/MSR.2010.5463279},
	attachments = {https://flosshub.org/sites/flosshub.org/files/31dambrosLanzaRobbes31.pdf},
	author = {D{\textquoteright}Ambros, Marco and Lanza, Michele and Robbes, Romain}
}
@conference {965,
	title = {Identifying licensing of jar archives using a code-search approach},
	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 = {151 - 160},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Cape Town, South Africa},
	abstract = {Free and open source software strongly promotes the reuse of source code. Some open source Java components/libraries are distributed as jar archives only containing the bytecode and some additional information. For whoever wanting to integrate this jar in her own project, it is important to determine the license(s) of the code from which the jar archive was produced, as this affects the way that such component can be used. This paper proposes an automatic approach to determine the license of jar archives, combining the use of a code-search engine with the automatic classification of licenses contained in textual flies enclosed in the jar. Results of an empirical study performed on 37 jars - from 17 different systems - indicate that this approach is able to successfully infer the jar licenses in over 95\% of the cases, but that in many cases the license in textual flies may differ from the one of the classes contained in the jar.},
	keywords = {apache, bytecode, classification, eclipse, google code, jar, java, licenses, source code},
	isbn = {978-1-4244-6802-7},
	doi = {10.1109/MSR.2010.5463282},
	attachments = {https://flosshub.org/sites/flosshub.org/files/151msr2010.pdf},
	author = {Di Penta, Massimiliano and Daniel M. German and Antoniol, Giuliano}
}
@conference {964,
	title = {Mining subclassing directives to improve framework reuse},
	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 = {141 - 150},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Cape Town, South Africa},
	abstract = {To help developers in using frameworks, good documentation is crucial. However, it is a challenge to create high quality documentation especially of hotspots in white-box frameworks. This paper presents an approach to documentation of object-oriented white-box frameworks which mines from client code four different kinds of documentation items, which we call subclassing directives. A case study on the Eclipse JFace user-interface framework shows that the approach can improve the state of API documentation w.r.t. subclassing directives.},
	keywords = {api, documentation, eclipse, frameworks, jface, source code},
	isbn = {978-1-4244-6802-7},
	doi = {10.1109/MSR.2010.5463347},
	attachments = {https://flosshub.org/sites/flosshub.org/files/141Mining-Subclassing-Directives-to-Improve-Framework-Reuse.pdf},
	author = {Bruch, Marcel and Mezini, Mira and Monperrus, Martin}
}
@conference {949,
	title = {Predicting the severity of a reported bug},
	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 = {1 - 10},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Cape Town, South Africa},
	abstract = {The severity of a reported bug is a critical factor in deciding how soon it needs to be fixed. Unfortunately, while clear guidelines exist on how to assign the severity of a bug, it remains an inherent manual process left to the person reporting the bug. In this paper we investigate whether we can accurately predict the severity of a reported bug by analyzing its textual description using text mining algorithms. Based on three cases drawn from the open-source community (Mozilla, Eclipse and GNOME), we conclude that given a training set of sufficient size (approximately 500 reports per severity), it is possible to predict the severity with a reasonable accuracy (both precision and recall vary between 0.65-0.75 with Mozilla and Eclipse; 0.70-0.85 in the case of GNOME).},
	keywords = {bug reports, eclipse, gnome, mozilla, severity, text mining},
	isbn = {978-1-4244-6802-7},
	doi = {10.1109/MSR.2010.5463284},
	attachments = {https://flosshub.org/sites/flosshub.org/files/1lamkanfiDemeyer1.pdf},
	author = {Lamkanfi, Ahmed and Demeyer, Serge and Giger, Emanuel and Goethals, Bart}
}
@conference {Rastkar:2010:SSA:1806799.1806872,
	title = {Summarizing software artifacts: a case study of bug reports},
	booktitle = {Proceedings of the 32nd ACM/IEEE International Conference on Software Engineering - Volume 1},
	series = {ICSE {\textquoteright}10},
	year = {2010},
	pages = {505{\textendash}514},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {Many software artifacts are created, maintained and evolved as part of a software development project. As software developers work on a project, they interact with existing project artifacts, performing such activities as reading previously filed bug reports in search of duplicate reports. These activities often require a developer to peruse a substantial amount of text. In this paper, we investigate whether it is possible to summarize software artifacts automatically and effectively so that developers could consult smaller summaries instead of entire artifacts. To provide focus to our investigation, we consider the generation of summaries for bug reports. We found that existing conversation-based generators can produce better results than random generators and that a generator trained specifically on bug reports can perform statistically better than existing conversation-based generators. We demonstrate that humans also find these generated summaries reasonable indicating that summaries might be used effectively for many tasks.},
	keywords = {bug reports, eclipse, gnome, human-centric software engineering, kde, machine learning, mozilla},
	isbn = {978-1-60558-719-6},
	doi = {10.1145/1806799.1806872},
	url = {http://doi.acm.org/10.1145/1806799.1806872},
	author = {Rastkar, Sarah and Murphy, Gail C. and Murray, Gabriel}
}
@conference {953,
	title = {When process data quality affects the number of bugs: Correlations in software engineering datasets},
	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 = {62 - 71},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Cape Town, South Africa},
	abstract = {Software engineering process information extracted from version control systems and bug tracking databases are widely used in empirical software engineering. In prior work, we showed that these data are plagued by quality deficiencies, which vary in its characteristics across projects. In addition, we showed that those deficiencies in the form of bias do impact the results of studies in empirical software engineering. While these findings affect software engineering researchers the impact on practitioners has not yet been substantiated. In this paper we, therefore, explore (i) if the process data quality and characteristics have an influence on the bug fixing process and (ii) if the process quality as measured by the process data has an influence on the product (i.e., software) quality. Specifically, we analyze six Open Source as well as two Closed Source projects and show that process data quality and characteristics have an impact on the bug fixing process: the high rate of empty commit messages in Eclipse, for example, correlates with the bug report quality. We also show that the product quality - measured by number of bugs reported - is affected by process data quality measures. These findings have the potential to prompt practitioners to increase the quality of their software process and its associated data quality.},
	keywords = {apache, bug reports, eclipse, gnome, log files, mozilla, netbeans, openoffice.org, version control},
	isbn = {978-1-4244-6802-7},
	doi = {10.1109/MSR.2010.5463286},
	attachments = {https://flosshub.org/sites/flosshub.org/files/62bachmann-msr10.pdf},
	author = {Bachmann, Adrian and Bernstein, Abraham}
}
@conference {937,
	title = {Assigning bug reports using a vocabulary-based expertise model of developers},
	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 = {131 - 140},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Vancouver, BC, Canada},
	abstract = {For popular software systems, the number of daily submitted bug reports is high. Triaging these incoming reports is a time consuming task. Part of the bug triage is the assignment of a report to a developer with the appropriate expertise. In this paper, we present an approach to automatically suggest developers who have the appropriate expertise for handling a bug report. We model developer expertise using the vocabulary found in their source code contributions and compare this vocabulary to the vocabulary of bug reports. We evaluate our approach by comparing the suggested experts to the persons who eventually worked on the bug. Using eight years of Eclipse development as a case study, we achieve 33.6\% top-1 precision and 71.0\% top-10 recall.},
	keywords = {bug reports, bugzilla, develect, developers, eclipse, expertise, scm},
	isbn = {978-1-4244-3493-0},
	doi = {10.1109/MSR.2009.5069491},
	attachments = {https://flosshub.org/sites/flosshub.org/files/131AssigningBugReports.pdf},
	author = {Matter, Dominique and Kuhn, Adrian and Nierstrasz, Oscar}
}
@conference {944,
	title = {Learning from defect removals},
	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 = {179 - 182},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Vancouver, BC, Canada},
	abstract = {Recent research has tried to identify changes in source code repositories that fix bugs by linking these changes to reports in issue tracking systems. These changes have been traced back to the point in time when they were previously modified as a way of identifying bug introducing changes. But we observe that not all changes linked to bug tracking systems are fixing bugs; some are enhancing the code. Furthermore, not all fixes are applied at the point in the code where the bug was originally introduced. We flesh out these observations with a manual review of several software projects, and use this opportunity to see how many defects are in the scope of static analysis tools.},
	keywords = {bug fixing, bugzilla, change management, cherry, cvs, eclipse, groovy, launching, source code, svn, text editor},
	isbn = {978-1-4244-3493-0},
	doi = {10.1109/MSR.2009.5069500},
	attachments = {https://flosshub.org/sites/flosshub.org/files/179LearnFromDefects-MSR09.pdf},
	author = {Ayewah, Nathaniel and Pugh, William}
}
@conference {bird2009pat,
	title = {{Putting it All Together: Using Socio-Technical Networks to Predict Failures}},
	booktitle = {Proceedings of the 17th International Symposium on Software Reliability Engineering},
	year = {2009},
	note = {First, we build each type of network separately and use network analysis on both to gather metrics for use in a predictive model. Second, we build a socio-technical network which combines the nodes and edges from both the dependency network and the contribution network and use metrics gathered from this network in a predictive model.
We evaluate our approach by collecting data from Mi- crosoft Windows Vista and ECLIPSE development and using logistic regression analysis.},
	abstract = {Studies have shown that social factors in development organizations have a dramatic effect on software quality. Separately, program dependency information has also been used successfully to predict which software components are more fault prone. Interestingly, the influence of these two phenomena have only been studied separately. Intuition and practical experience suggests, however, that task assignment (i.e. who worked on which components and how much) and dependency structure (which components have dependencies on others) together interact to influence the quality of the resulting software. We study the influence of combined socio-technical software networks on the fault-proneness of individual software components within a system. The network properties of a software component in this combined network are able to predict if an entity is failure prone with greater accuracy than prior methods which use dependency or contribution information in isolation. We evaluate our approach in different settings by using it on Windows Vista and across six releases of the Eclipse development environment including using models built from one release to predict failure prone components in the next release. We compare this to previous work. In every case, our method performs as well or better and is able to more accurately identify those software components that have more post-release failures, with precision and recall rates as high as 85\%.},
	keywords = {eclipse, microsoft, social network, vista, windows},
	attachments = {https://flosshub.org/sites/flosshub.org/files/bird2009pat.pdf},
	author = {Christian Bird and Nachiappan Nagappan and Devanbu, Premkumar and Gall, Harald and Brendan Murphy}
}
@conference {926,
	title = {Tracking concept drift of software projects using defect prediction quality},
	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 = {51 - 60},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Vancouver, BC, Canada},
	abstract = {Defect prediction is an important task in the mining of software repositories, but the quality of predictions varies strongly within and across software projects. In this paper we investigate the reasons why the prediction quality is so fluctuating due to the altering nature of the bug (or defect) fixing process. Therefore, we adopt the notion of a concept drift, which denotes that the defect prediction model has become unsuitable as set of influencing features has changed - usually due to a change in the underlying bug generation process (i.e., the concept). We explore four open source projects (Eclipse, OpenOffice, Netbeans and Mozilla) and construct file-level and project-level features for each of them from their respective CVS and Bugzilla repositories. We then use this data to build defect prediction models and visualize the prediction quality along the time axis. These visualizations allow us to identify concept drifts and - as a consequence - phases of stability and instability expressed in the level of defect prediction quality. Further, we identify those project features, which are influencing the defect prediction quality using both a tree induction-algorithm and a linear regression model. Our experiments uncover that software systems are subject to considerable concept drifts in their evolution history. Specifically, we observe that the change in number of authors editing a file and the number of defects fixed by them contribute to a project{\textquoteright}s concept drift and therefore influence the defect prediction quality. Our findings suggest that project managers using defect prediction models for decision making should be aware of the actual phase of stability or instability due to a potential concept drift.},
	keywords = {bugzilla, cvs, defect prediction, eclipse, mozilla, netbeans, openoffice},
	isbn = {978-1-4244-3493-0},
	doi = {10.1109/MSR.2009.5069480},
	attachments = {https://flosshub.org/sites/flosshub.org/files/51MSR2009_0111_Ekanayake_Jayalath.pdf},
	author = {Ekanayake, Jayalath and Tappolet, Jonas and Gall, Harald C. and Bernstein, Abraham}
}
@conference {939,
	title = {On what basis to recommend: Changesets or interactions?},
	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 = {155 - 158},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Vancouver, BC, Canada},
	abstract = {Different flavours of recommendation systems have been proposed to help software developers perform software evolution tasks. A number of these recommendation systems are based on changesets. When changeset information is used, recommendations are based on only the end result of the activity undertaken to complete a task. In this paper, we report on an investigation that compared how recommendations based on changesets compare to recommendations based on interactions collected as a programmer performed the task that resulted in a changeset. To provide a common basis for the comparison, our investigation considered how bug reports considered similar based on changeset information compare to bug reports considered similar based on interaction information. We found that there is no direct relationship between the bug reports found similar with the different methods, suggesting that each comparison methods captures a different aspect of the problem.},
	keywords = {bug reports, changeset, eclipse, mylyn},
	isbn = {978-1-4244-3493-0},
	doi = {10.1109/MSR.2009.5069494},
	author = {Rastkar, Sarah and Murphy, Gail C.}
}
@conference {Wermelinger:2008:AEE:1370750.1370783,
	title = {Analyzing the evolution of eclipse plugins},
	booktitle = {Proceedings of the 2008 international working conference on Mining software repositories},
	series = {MSR {\textquoteright}08},
	year = {2008},
	pages = {133{\textendash}136},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {Eclipse is a good example of a modern component-based complex system that is designed for long-term evolution, due to its architecture of reusable and extensible components. This paper presents our preliminary results about the evolution of Eclipse{\textquoteright}s architecture, based on a lightweight and scalable analysis of the metadata in Eclipse{\textquoteright}s sources. We find that the development of Eclipse follows a systematic process: most architectural changes take place in milestones, and maintenance releases only make exceptional changes to component dependencies. We also found a stable architectural core that remains since the first release.},
	keywords = {architectural evolution, cvs, eclipse, metadata, msr challenge, releases, source code},
	isbn = {978-1-60558-024-1},
	doi = {http://doi.acm.org/10.1145/1370750.1370783},
	url = {http://doi.acm.org/10.1145/1370750.1370783},
	author = {Wermelinger, Michel and Yu, Yijun}
}
@conference {Hata:2008:EFF:1370750.1370772,
	title = {An extension of fault-prone filtering using precise training and a dynamic threshold},
	booktitle = {Proceedings of the 2008 international working conference on Mining software repositories},
	series = {MSR {\textquoteright}08},
	year = {2008},
	pages = {89{\textendash}98},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {Fault-prone module detection in source code is important for assurance of software quality. Most previous fault-prone detection approaches have been based on software metrics. Such approaches, however, have difficulties in collecting the metrics and in constructing mathematical models based on the metrics. To mitigate such difficulties, we have proposed a novel approach for detecting fault-prone modules using a spam-filtering technique, named Fault-Prone Filtering. In our approach, fault-prone modules are detected in such a way that the source code modules are considered as text files and are applied to the spam filter directly. In practice, we use the training only errors procedure and apply this procedure to fault-prone. Since no pre-training is required, this procedure can be applied to an actual development field immediately. This paper describes an extension of the training only errors procedures. We introduce a precise unit of training, "modified lines of code," instead of methods. In addition, we introduce the dynamic threshold for classification. The result of the experiment shows that our extension leads to twice the precision with about the same recall, and improves 15\% on the best F1 measurement.},
	keywords = {eclipse, fault-prone modules, spam filter, text mining},
	isbn = {978-1-60558-024-1},
	doi = {http://doi.acm.org/10.1145/1370750.1370772},
	url = {http://doi.acm.org/10.1145/1370750.1370772},
	attachments = {https://flosshub.org/sites/flosshub.org/files/p89-hata.pdf},
	author = {Hata, Hideaki and Mizuno, Osamu and Kikuno, Tohru}
}
@conference {972,
	title = {Extracting structural information from bug reports},
	booktitle = {Proceedings of the 2008 international workshop on Mining software repositories  - MSR {\textquoteright}08},
	year = {2008},
	month = {05/2008},
	pages = {27-30},
	publisher = {ACM Press},
	organization = {ACM Press},
	address = {New York, New York, USA},
	abstract = {In software engineering experiments, the description of bug reports is typically treated as natural language text, although it often contains stack traces, source code, and patches. Neglecting such structural elements is a loss of valuable information; structure usually leads to a better performance of machine learning approaches. In this paper, we present a tool called infoZilla that detects structural elements from bug reports with near perfect accuracy and allows us to extract them. We anticipate that infoZilla can be used to leverage data from bug reports at a different granularity level that can facilitate interesting research in the future.},
	keywords = {bug reports, eclipse, enumerations, infozilla, natural language, patches, source code, stack trace},
	isbn = {9781605580241},
	doi = {10.1145/1370750.1370757},
	attachments = {https://flosshub.org/sites/flosshub.org/files/p27-bettenburg.pdf},
	author = {Premraj, Rahul and Zimmermann, Thomas and Kim, Sunghun and Bettenburg, Nicolas}
}
@conference {Zhang:2008:ISG:1370750.1370785,
	title = {An initial study of the growth of eclipse defects},
	booktitle = {Proceedings of the 2008 international working conference on Mining software repositories},
	series = {MSR {\textquoteright}08},
	year = {2008},
	pages = {141{\textendash}144},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {We analyze the Eclipse defect data from June 2004 to November 2007, and find that the growth of the number of defects can be well modeled by polynomial functions. Furthermore, we can predict the number of future Eclipse defects based on the nature of defect growth.},
	keywords = {bug reports, defect growth model, defect prediction, eclipse, msr challenge, polynomial regression},
	isbn = {978-1-60558-024-1},
	doi = {http://doi.acm.org/10.1145/1370750.1370785},
	url = {http://doi.acm.org/10.1145/1370750.1370785},
	author = {Zhang, Hongyu}
}
@conference {Schuler:2008:MUE:1370750.1370779,
	title = {Mining usage expertise from version archives},
	booktitle = {Proceedings of the 2008 international working conference on Mining software repositories},
	series = {MSR {\textquoteright}08},
	year = {2008},
	month = {05/2008},
	pages = {121{\textendash}124},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {In software development, there is an increasing need to find and connect developers with relevant expertise. Existing expertise recommendation systems are mostly based on variations of the Line 10 Rule: developers who changed a file most often have the most implementation expertise. In this paper, we introduce the concept of usage expertise, which manifests itself whenever developers are using functionality, e.g., by calling API methods. We present preliminary results for the ECLIPSE project that demonstrate that our technique allows to recommend experts for files with no or little history, identify developers with similar expertise, and measure the usage of API methods.},
	keywords = {api, computer-supported cooperative work, eclipse, expertise, recommendation, scm, software repository, source code},
	isbn = {978-1-60558-024-1},
	doi = {http://doi.acm.org/10.1145/1370750.1370779},
	url = {http://doi.acm.org/10.1145/1370750.1370779},
	attachments = {https://flosshub.org/sites/flosshub.org/files/p121-schuler.pdf},
	author = {Schuler, David and Zimmermann, Thomas}
}
@conference {Holmes:2008:NGE:1370750.1370787,
	title = {A newbie{\textquoteright}s guide to eclipse APIs},
	booktitle = {Proceedings of the 2008 international working conference on Mining software repositories},
	series = {MSR {\textquoteright}08},
	year = {2008},
	pages = {149{\textendash}152},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {Eclipse has evolved from a fledgling Java IDE into a mature software ecosystem. One of the greatest benefits Eclipse provides developers is flexibility; however, this is not without cost. New Eclipse developers often find the framework to be large and confusing. Determining which parts of the framework they should be using can be a difficult task as Eclipse documentation tends to be either very high-level, focusing on the design of the framework, or low-level, focusing on specific APIs. We have developed a tool called PopCon that provides a bridge between high-level design documentation and low-level API documentation by statically analyzing a framework and several of its clients and providing a ranked list of the relative popularity of its APIs. We have applied PopCon to the Eclipse framework for this challenge to help newbie Eclipse developers identify some of the most relevant APIs for their tasks.},
	keywords = {API popularity, documentation, eclipse, mining software repositories, module, msr challenge, PopCon, popularity},
	isbn = {978-1-60558-024-1},
	doi = {http://doi.acm.org/10.1145/1370750.1370787},
	url = {http://doi.acm.org/10.1145/1370750.1370787},
	author = {Holmes, Reid and Walker, Robert J.}
}
@conference {Siy:2008:SDW:1370750.1370784,
	title = {Summarizing developer work history using time series segmentation: challenge report},
	booktitle = {Proceedings of the 2008 international working conference on Mining software repositories},
	series = {MSR {\textquoteright}08},
	year = {2008},
	month = {05/2008},
	pages = {137{\textendash}140},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {Temporal segmentation partitions time series data with the intent of producing more homogeneous segments. It is a technique used to preprocess data so that subsequent time series analysis on individual segments can detect trends that may not be evident when performing time series analysis on the entire dataset.

This technique allows data miners to partition a large dataset without making any assumption of periodicity or any other a priori knowledge of the dataset{\textquoteright}s features.

We investigate the insights that can be gained from the application of time series segmentation to software version repositories. Software version repositories from large projects contain on the order of hundreds of thousands of timestamped entries or more. It is a continuing challenge to aggregate such data so that noise is reduced and important characteristics are brought out.

In this paper, we present a way to summarize developer work history in terms of the files they have modified over time by segmenting the CVS change data of individual Eclipse developers. We show that the files they modify tends to change significantly over time though most of them tend to work within the same directories.},
	keywords = {contributions, cvs, developers, eclipse, msr challenge, temporal segmentation, time series, work history},
	isbn = {978-1-60558-024-1},
	doi = {http://doi.acm.org/10.1145/1370750.1370784},
	url = {http://doi.acm.org/10.1145/1370750.1370784},
	author = {Siy, Harvey and Chundi, Parvathi and Subramaniam, Mahadevan}
}
@conference {Herraiz:2008:TSB:1370750.1370786,
	title = {Towards a simplification of the bug report form in eclipse},
	booktitle = {Proceedings of the 2008 international working conference on Mining software repositories},
	series = {MSR {\textquoteright}08},
	year = {2008},
	pages = {145{\textendash}148},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {We believe that the bug report form of Eclipse contains too many fields, and that for some fields, there are too many options. In this MSR challenge report, we focus in the case of the severity field. That field contains seven different levels of severity. Some of them seem very similar, and it is hard to distinguish among them. Users assign severity, and developers give priority to the reports depending on their severity. However, if users can not distinguish well among the various severity options, they will probably assign different priorities to bugs that require the same priority. We study the mean time to close bugs reported in Eclipse, and how the severity assigned by users affects this time. The results shows that classifying by time to close, there are less clusters of bugs than levels of severity. We therefore conclude that there is a need to make a simpler bug report form.},
	keywords = {bug fixing, bug report, bug tracking system, classification, eclipse, msr challenge, severity},
	isbn = {978-1-60558-024-1},
	doi = {http://doi.acm.org/10.1145/1370750.1370786},
	url = {http://doi.acm.org/10.1145/1370750.1370786},
	author = {Herraiz, Israel and Daniel M. German and Jesus M. Gonzalez-Barahona and Gregorio Robles}
}
@article {springerlink:10.1007/s10588-006-9006-3,
	title = {Correlating temporal communication patterns of the Eclipse open source community with performance and creativity},
	journal = {Computational \&amp; Mathematical Organization Theory},
	volume = {13},
	year = {2007},
	note = {"Social network data was collected from the Eclipse component development groups{\textquoteright} online mailing lists by using the online process tool (Gloor and Zhao, 2004). Data on bugs and enhancements for each group was collected from the Eclipse bugzilla database (Eclipse bugzilla, 2004). The social network data was analyzed with the TeCFlow tool (Gloor and Zhao, 2004)."
"The study is based on data from the three main projects of the Eclipse open source development community, namely {\textquotedblleft}eclipse{\textquotedblright}, {\textquotedblleft}tools{\textquotedblright} and {\textquotedblleft}technology{\textquotedblright}. We have chosen thirty-three different component development groups for analysis."
"The online process tool (online process tool, 2004) was utilized to collect communication data from their mailing list archives. The online process tool runs a robot that searches for URLs in the projects{\textquoteright} mailing list archives to compile a list of the possible URL links. It then extracts communication data as tuples in the form of {\textquotedblleft}sender, receiver, communication type, timestamp, communication contents{\textquotedblright} and stores it in the database. Further, bugs and enhancement data were collected from the Eclipse bugzilla database."},
	pages = {17-27},
	publisher = {Springer Netherlands},
	abstract = {This paper studies the temporal communication patterns of online communities of developers and users of the open source Eclipse Java development environment. It measures the productivity of each community and seeks to identify correlations that exist between group communication characteristics and productivity attributes. The study uses the TeCFlow (Temporal Communication Flow) visualizer to create movie maps of the knowledge flow by analyzing the publicly accessible Eclipse developer mailing lists as an approximation of the social networks of developers and users. Thirty-three different Eclipse communities discussing development and use of components of Eclipse such as the Java Development Tools, the different platform components, the C/C++ Development Tools and the AspectJ extension have been analyzed over a period of six months. The temporal evolution of social network variables such as betweenness centrality, density, contribution index, and degree have been computed and plotted. Productivity of each development group is measured in terms of two indices, namely performance and creativity. Performance of a group is defined as the ratio of new bugs submitted compared with bugs fixed within the same period of time. Creativity is calculated as a function of new features proposed and implemented. Preliminary results indicate that there is a correlation between attributes of social networks such as density and betweenness centrality and group productivity measures in an open source development community. We also find a positive correlation between changes over time in betweenness centrality and creativity, and a negative correlation between changes in betweenness centrality and performance.},
	keywords = {bug fixing, bugs, bugzilla, communication, creativity, developers, eclipse, email, email archives, feature requests, mailing lists, performance, productivity},
	issn = {1381-298X},
	url = {http://dx.doi.org/10.1007/s10588-006-9006-3},
	attachments = {https://flosshub.org/sites/flosshub.org/files/16.pdf},
	author = {Kidane, Yared and Gloor, Peter}
}
@conference {992,
	title = {Determining Implementation Expertise from Bug Reports},
	booktitle = {Fourth International Workshop on Mining Software Repositories (MSR{\textquoteright}07:ICSE Workshops 2007)},
	year = {2007},
	pages = {2 - 2},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Minneapolis, MN, USA},
	abstract = {As developers work on a software product they accumulate expertise, including expertise about the code base of the software product. We call this type of expertise "implementation expertise". Knowing the set of developers who have implementation expertise for a software product has many important uses. This paper presents an empirical evaluation of two approaches to determining implementation expertise from the data in source and bug repositories. The expertise sets created by the approaches are compared to those provided by experts and evaluated using the measures of precision and recall. We found that both approaches are good at finding all of the appropriate developers, although they vary in how many false positives are returned.},
	keywords = {bug reports, developers, eclipse, expertise, repository, scm, source code},
	isbn = {0-7695-2950-X},
	doi = {10.1109/MSR.2007.7},
	attachments = {https://flosshub.org/sites/flosshub.org/files/28300002.pdf},
	author = {Anvik, John and Murphy, Gail C.}
}
@conference {1017,
	title = {Forecasting the Number of Changes in Eclipse Using Time Series Analysis},
	booktitle = {Fourth International Workshop on Mining Software Repositories (MSR{\textquoteright}07:ICSE Workshops 2007)},
	year = {2007},
	pages = {32 - 32},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Minneapolis, MN, USA},
	abstract = {In order to predict the number of changes in the following months for the project Eclipse, we have applied a statistical (non-explanatory) model based on time series analysis. We have obtained the monthly number of changes in the CVS repository of Eclipse, using the CVSAnalY tool. The input to our model was the filtered series of the number of changes per month, and the output was the number of changes per month for the next three months. Then we aggregated the results of the three months to obtain the total number of changes in the given period in the challenge.},
	keywords = {change management, cvs, cvsanaly, eclipse, prediction},
	isbn = {0-7695-2950-X},
	doi = {10.1109/MSR.2007.10},
	attachments = {https://flosshub.org/sites/flosshub.org/files/28300032.pdf},
	author = {Herraiz, Israel and Jesus M. Gonzalez-Barahona and Gregorio Robles}
}
@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 {1015,
	title = {Mining Eclipse Developer Contributions via Author-Topic Models},
	booktitle = {Fourth International Workshop on Mining Software Repositories (MSR{\textquoteright}07:ICSE Workshops 2007)},
	year = {2007},
	pages = {30 - 30},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Minneapolis, MN, USA},
	abstract = {We present the results of applying statistical author-topic models to a subset of the Eclipse 3.0 source code consisting of 2,119 source files and 700,000 lines of code from 59 developers. This technique provides an intuitive and automated framework with which to mine developer contributions and competencies from a given code base while simultaneously extracting software function in the form of topics. In addition to serving as a convenient summary for program function and developer activities, our study shows that topic models provide a meaningful, effective, and statistical basis for developer similarity analysis.},
	keywords = {contributions, developers, eclipse, expertise, mining challenge, msr challenge, source code, topics},
	isbn = {0-7695-2950-X},
	doi = {10.1109/MSR.2007.20},
	attachments = {https://flosshub.org/sites/flosshub.org/files/28300030.pdf},
	author = {Linstead, Erik and Rigor, Paul and Bajracharya, Sushil and Lopes, Cristina and Baldi, Pierre}
}
@conference {999,
	title = {Mining Software Repositories with iSPAROL and a Software Evolution Ontology},
	booktitle = {Fourth International Workshop on Mining Software RepositoriesFourth International Workshop on Mining Software Repositories (MSR{\textquoteright}07:ICSE Workshops 2007)},
	year = {2007},
	pages = {10 - 10},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Minneapolis, MN, USA},
	abstract = {One of the most important decisions researchers face when analyzing the evolution of software systems is the choice of a proper data analysis/exchange format. Most existing formats have to be processed with special programs written specifically for that purpose and are not easily extendible. Most scientists, therefore, use their own database(s) requiring each of them to repeat the work of writing the import/export programs to their format.

We present EvoOnt, a software repository data exchange format based on the Web Ontology Language (OWL). EvoOnt includes software, release, and bug-related information. Since OWL describes the semantics of the data, EvoOnt is (1) easily extendible, (2) comes with many existing tools, and (3) allows to derive assertions through its inherent Description Logic reasoning capabilities.

The paper also shows iSPARQL -- our SPARQL-based Semantic Web query engine containing similarity joins. Together with EvoOnt, iSPARQL can accomplish a sizable number of tasks sought in software repository mining projects, such as an assessment of the amount of change between versions or the detection of bad code smells. To illustrate the usefulness of EvoOnt (and iSPARQL), we perform a series of experiments with a real-world Java project. These show that a number of software analyses can be reduced to simple iSPARQL queries on an EvoOnt dataset.},
	keywords = {database, eclipse, evoont, java, owl, semantic, sparql},
	isbn = {0-7695-2950-X},
	doi = {10.1109/MSR.2007.21},
	attachments = {https://flosshub.org/sites/flosshub.org/files/28300010.pdf},
	author = {Kiefer, Christoph and Bernstein, Abraham and Tappolet, Jonas}
}
@conference {1016,
	title = {Predicting Defects and Changes with Import Relations},
	booktitle = {Fourth International Workshop on Mining Software Repositories (MSR{\textquoteright}07:ICSE Workshops 2007)},
	year = {2007},
	pages = {31 - 31},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Minneapolis, MN, USA},
	abstract = {Lowering the number of defects and estimating the development time of a software project are two important goals of software engineering. To predict the number of defects and changes we train models with import relations. This enables us to decrease the number of defects by more efficient testing and to assess the effort needed in respect to the number of changes.},
	keywords = {defects, eclipse, effort estimation, mining challenge, msr challenge, prediction},
	isbn = {0-7695-2950-X},
	doi = {10.1109/MSR.2007.24},
	attachments = {https://flosshub.org/sites/flosshub.org/files/28300031.pdf},
	author = {Schroter, Adrian}
}
@conference {1014,
	title = {Predicting Eclipse Bug Lifetimes},
	booktitle = {Fourth International Workshop on Mining Software RepositoriesFourth International Workshop on Mining Software Repositories (MSR{\textquoteright}07:ICSE Workshops 2007)},
	year = {2007},
	pages = {29 - 29},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Minneapolis, MN, USA},
	abstract = {In non-trivial software development projects planning and allocation of resources is an important and difficult task. Estimation of work time to fix a bug is commonly used to support this process. This research explores the viability of using data mining tools to predict the time to fix a bug given only the basic information known at the beginning of a bug{\textquoteright}s lifetime. To address this question, a historical portion of the Eclipse Bugzilla database is used for modeling and predicting bug lifetimes. A bug history transformation process is described and several data mining models are built and tested. Interesting behaviours derived from the models are documented. The models can correctly predict up to 34.9\% of the bugs into a discretized log scaled lifetime class.},
	keywords = {bug fixing, bugzilla, classification, eclipse, effort estimation, mining challenge, msr challenge, prediction, weka},
	isbn = {0-7695-2950-X},
	doi = {10.1109/MSR.2007.25},
	attachments = {https://flosshub.org/sites/flosshub.org/files/28300029.pdf},
	author = {Panjer, Lucas D.}
}
@conference {994,
	title = {Recommending Emergent Teams},
	booktitle = {Fourth International Workshop on Mining Software Repositories (MSR{\textquoteright}07:ICSE Workshops 2007)},
	year = {2007},
	pages = {5 - 5},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Minneapolis, MN, USA},
	abstract = {To build successful complex software systems, developers must collaborate with each other to solve issues. To facilitate this collaboration, specialized tools, such as chat and screen sharing, are being integrated into development environments. Currently, these tools require a developer to maintain a list of other developers with whom they may wish to communicate and to determine who within this list has expertise for a specific situation. For large, dynamic projects, like several successful open-source projects, these requirements place an unreasonable burden on the developer. In this paper, we show how the structure of a team emerges from how developers change software artifacts. We introduce the Emergent Expertise Locator (EEL) that uses emergent team information to propose experts to a developer within their development environment as the developer works. We found that EEL produces, on average, results with higher precision and higher recall than an existing heuristic for expertise recommendation.},
	keywords = {bugzilla, developers, eclipse, evolution, expertise, Firefox, teams},
	isbn = {0-7695-2950-X},
	doi = {10.1109/MSR.2007.27},
	attachments = {https://flosshub.org/sites/flosshub.org/files/28300005.pdf},
	author = {Minto, Shawn and Murphy, Gail C.}
}
@conference {993,
	title = {Spam Filter Based Approach for Finding Fault-Prone Software Modules},
	booktitle = {Fourth International Workshop on Mining Software Repositories (MSR{\textquoteright}07:ICSE Workshops 2007)},
	year = {2007},
	pages = {4 - 4},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Minneapolis, MN, USA},
	abstract = {Because of the increase of needs for spam e-mail detection, the spam filtering technique has been improved as a convenient and effective technique for text mining. We propose a novel approach to detect fault-prone modules in a way that the source code modules are considered as text files and are applied to the spam filter directly. In order to show the applicability of our approach, we conducted experimental applications using source code repositories of Java based open source developments. The result of experiments shows that our approach can classify more than 75\% of software modules correctly.},
	keywords = {argouml, bug reports, classification, eclipse, java, modules, scm, spam, text mining},
	isbn = {0-7695-2950-X},
	doi = {10.1109/MSR.2007.29},
	attachments = {https://flosshub.org/sites/flosshub.org/files/28300004.pdf},
	author = {Mizuno, Osamu and Ikami, Shiro and Nakaichi, Shuya and Kikuno, Tohru}
}
@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 {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 {Breu:2006:MEC:1137983.1138006,
	title = {Mining eclipse for cross-cutting concerns},
	booktitle = {Proceedings of the 2006 international workshop on Mining software repositories},
	series = {MSR {\textquoteright}06},
	year = {2006},
	pages = {94{\textendash}97},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {Software may contain functionality that does not align with its architecture. Such cross-cutting concerns do not exist from the beginning but emerge over time. By analysing where developers add code to a program, our history-based mining identifies cross-cutting concerns in a two-step process. First, we mine CVS archives for sets of methods where a call to a specific single method was added. In a second step, such simple cross-cutting concerns are combined to complex cross-cutting concerns. To compute these efficiently, we apply formal concept analysis{\textemdash}an algebraic theory. History-based mining scales well: we are the first to report aspects mined from an industrial-sized project like Eclipse. For example, we identified a locking concern that crosscuts 1284 methods.},
	keywords = {aspects, concept analysis, cvs, eclipse, source code},
	isbn = {1-59593-397-2},
	doi = {http://doi.acm.org/10.1145/1137983.1138006},
	url = {http://doi.acm.org/10.1145/1137983.1138006},
	attachments = {https://flosshub.org/sites/flosshub.org/files/94MiningEclipse.pdf},
	author = {Breu, Silvia and Zimmermann, Thomas and Lindig, Christian}
}
@conference {German:2006:UEA:1137983.1138020,
	title = {Using evolutionary annotations from change logs to enhance program comprehension},
	booktitle = {Proceedings of the 2006 international workshop on Mining software repositories},
	series = {MSR {\textquoteright}06},
	year = {2006},
	pages = {159{\textendash}162},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {Evolutionary annotations are descriptions of how source code evolves over time. Typical source comments, given their static nature, are usually inadequate for describing how a program has evolved over time; instead, source code comments are typically a description of what a program currently does. We propose the use of evolutionary annotations as a way of describing the rationale behind changes applied to a given program (for example "These lines were added to ..."). Evolutionary annotations can assist a software developer in the understanding of how a given portion of source code works by showing him how the source has evolved into its current form.In this paper we describe a method to automatically create evolutionary annotations from change logs, defect tracking systems and mailing lists. We describe the design of a prototype for Eclipse that can filter and present these annotations alongside their corresponding source code and in workbench views. We use Apache as a test case to demonstrate the feasibility of this approach.},
	keywords = {annotations, apache, bug tracking, change history, eclipse, evolutionary, log files, mailing lists, mining software repositories, software evolution, version control},
	isbn = {1-59593-397-2},
	doi = {http://doi.acm.org/10.1145/1137983.1138020},
	url = {http://doi.acm.org/10.1145/1137983.1138020},
	attachments = {https://flosshub.org/sites/flosshub.org/files/159UsingEvolutionary.pdf},
	author = {Daniel M. German and Peter C. Rigby and Storey, Margaret-Anne}
}
@conference {Anvik:2006:FTB:1134285.1134336,
	title = {Who should fix this bug?},
	booktitle = {Proceedings of the 28th international conference on Software engineering},
	series = {ICSE {\textquoteright}06},
	year = {2006},
	pages = {361{\textendash}370},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {Open source development projects typically support an open bug repository to which both developers and users can report bugs. The reports that appear in this repository must be triaged to determine if the report is one which requires attention and if it is, which developer will be assigned the responsibility of resolving the report. Large open source developments are burdened by the rate at which new bug reports appear in the bug repository. In this paper, we present a semi-automated approach intended to ease one part of this process, the assignment of reports to a developer. Our approach applies a machine learning algorithm to the open bug repository to learn the kinds of reports each developer resolves. When a new report arrives, the classifier produced by the machine learning technique suggests a small number of developers suitable to resolve the report. With this approach, we have reached precision levels of 57\% and 64\% on the Eclipse and Firefox development projects respectively. We have also applied our approach to the gcc open source development with less positive results. We describe the conditions under which the approach is applicable and also report on the lessons we learned about applying machine learning to repositories used in open source development.},
	keywords = {bug fixing, bug report, bug report assignment, bug triage, eclipse, Firefox, gcc, issue tracking, machine learning, problem tracking},
	isbn = {1-59593-375-1},
	doi = {10.1145/1134285.1134336},
	url = {http://doi.acm.org/10.1145/1134285.1134336},
	author = {Anvik, John and Hiew, Lyndon and Murphy, Gail C.}
}
@conference {795,
	title = {The challenges of creating open source education software: the Gild experience},
	booktitle = {OSS2005: Open Source Systems },
	year = {2005},
	pages = {338-340},
	keywords = {COMMUNITY, eclipse, learning environment, novice programmers, open source, programming environment},
	url = {http://pascal.case.unibz.it/handle/2038/1539},
	author = {Daniel M. German and Rigby, Peter and Cubranic, Davor and Storey, Margaret-Anne and Thomson, Suzanne}
}
@conference {Fielding:2005:SAO:1062455.1062474,
	title = {Software architecture in an open source world},
	booktitle = {Proceedings of the 27th international conference on Software engineering},
	series = {ICSE {\textquoteright}05},
	year = {2005},
	pages = {43{\textendash}43},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {In spite of the hype and hysteria surrounding open source software development, there is very little that can be said of open source in general. Open source projects range in scope from the miniscule, such as the thousands of non-maintained code dumps left behind at the end of class projects, dissertations, and failed commercial ventures, to the truly international, with thousands of developers collaborating, directly or indirectly, on a common platform. One characteristic that is shared by the largest and most successful open source projects, however, is a software architecture designed to promote anarchic collaboration through extensions while at the same time preserving centralized control over the interfaces. This talk features a survey of the state-of-the-practice in open source development in regards to software architecture, with particular emphasis on the modular extensibility interfaces within several of the most successful projects, including Apache httpd, Eclipse, Mozilla Firefox, Linux kernel, and the World Wide Web (which few people recognize as an open source project in itself). These projects fall under the general category of collaborative open source software development, which emphasizes community aspects of software engineering in order to compensate for the often-volunteer nature of core developers and take advantage of the scalability obtainable through Internet-based virtual organizations.},
	keywords = {apache, collaborative open source development, eclipse, extensibility, Firefox, linux, linux kernel, loose coupling, modularity, mozilla, open source, software architecture},
	isbn = {1-58113-963-2},
	doi = {10.1145/1062455.1062474},
	url = {http://doi.acm.org/10.1145/1062455.1062474},
	author = {Roy T. Fielding}
}
@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 {1160,
	title = {Adopting OSS Methods by Adopting OSS Tools},
	booktitle = {Proceedings of the 2nd ICSE Workshop on Open Source},
	year = {2002},
	abstract = {The open source movement has created and used a set of software engineering tools with features that fit the characteristics of open source development processes. To a large extent, the open source culture and methodology are conveyed to new developers via the toolset itself, and through the demonstrated usage of these tools on existing projects. The rapid and wide adoption of open source tools stands in stark contrast to the difficulties encountered in adopting traditional CASE tools. This paper explores the characteristics that make these tools adoptable and how adopting them may influence software development processes.},
	keywords = {ant, argouml, bugzilla, cactus, cvs, developers, eclipse, emacs, email, faq, junit, mailing lists, make, netbeans, package management, rpm, scarab, subversion, teams, tools, torque, WORK},
	attachments = {https://flosshub.org/sites/flosshub.org/files/Robbins.pdf},
	author = {Robbins, Jason E.}
}
