@proceedings {1908,
	title = {How Open Source Projects use Static Code Analysis Tools in Continuous Integration Pipelines},
	year = {2017},
	note = {Data: the paper studies the use of ASCATs (Automated Static Code Analysis Tools) within CI pipelines of 20 popular Java open source projects hosted on GitHub and using Travis CI to support CI activities},
	month = {05/2017},
	pages = {334-344},
	abstract = {Static analysis tools are often used by software developers
to entail early detection of potential faults, vulnerabilities,
code smells, or to assess the source code adherence to coding
standards and guidelines. Also, their adoption within Continuous
Integration (CI) pipelines has been advocated by researchers and
practitioners. This paper studies the usage of static analysis tools
in 20 Java open source projects hosted on GitHub and using
Travis CI as continuous integration infrastructure. Specifically,
we investigate (i) which tools are being used and how they are
configured for the CI, (ii) what types of issues make the build fail
or raise warnings, and (iii) whether, how, and after how long are
broken builds and warnings resolved. Results indicate that in the
analyzed projects build breakages due to static analysis tools are
mainly related to adherence to coding standards, and there is also
some attention to missing licenses. Build failures related to tools
identifying potential bugs or vulnerabilities occur less frequently,
and in some cases such tools are activated in a {\textquotedblleft}softer{\textquotedblright} mode,
without making the build fail. Also, the study reveals that build
breakages due to static analysis tools are quickly fixed by actually
solving the problem, rather than by disabling the warning, and
are often properly documented.},
	keywords = {continuous integration, empirical study, static analysis},
	doi = {10.1109/MSR.2017.2},
	author = {Zampetti, Fiorella and Scalabrino, Simone and Oliveto, Rocco and Canfora, Gerardo and Di Penta, Massimiliano}
}
@article {1868,
	title = {Managing knowledge sharing in distributed innovation from the perspective of developers: empirical study of open source software projects in China},
	journal = {Technology Analysis \& Strategic Management},
	volume = {2929143029},
	year = {2017},
	month = {01/2017},
	pages = {1 - 22},
	abstract = {Knowledge sharing is the key factor that influences the performance of open source software (OSS) projects, which are the representative cases of distributed innovation. This paper aims to explore the mechanism of knowledge sharing in OSS projects from the perspective of developers in China. A quantitative method with the analysis of 403 valid questionnaires is adopted. A series of hypotheses about how distributed innovation (independent variables) influences knowledge sharing (mediating variable) and then affects the performance of OSS projects (dependent variable) are tested and approved. On the one side, we argue that developers will actively affect knowledge sharing in terms of participative motivation, social network and organisational culture. On the other hand, users may also affect the knowledge sharing when considering innovation willingness and capacity. It is interesting to find that social network is the most important factor in Chinese cases. It is strongly recommended to strengthen the collaboration between software companies and OSS communities.},
	keywords = {Distributed innovation, knowledge sharing, performance of OSS projects, user innovation},
	issn = {1465-3990},
	doi = {http://dx.doi.org/10.1080/09537325.2016.1194387},
	author = {Chen, Xiaohong and Zhou, Yuan and Probert, David and Su, Jun}
}
@proceedings {1888,
	title = {Technical Lag in Software Compilations: Measuring How Outdated a Software Deployment Is},
	volume = {496},
	year = {2017},
	month = {05/2017},
	pages = {182 - 192},
	publisher = {Springer International Publishing},
	abstract = {Large software compilations based on free, open source software (FOSS) packages are the basis for many software systems. When they are deployed in production, specific versions of the packages in the compilation are selected for installation. Over time, those versions become outdated with respect to the upstream software from which they are produced, and from the components available in the compilations as well. The fact that deployed components are outdated is not a problem in itself, but there is a price to pay for not being "as much updated as reasonable". This includes bug fixes and new features that could, at least potentially, be interesting for the deployed system. Therefore, a balance has to be maintained between "being up-to-date" and "keeping the good old working versions". This paper proposes a theoretical model (the "technical lag") for measuring how outdated a system is, with the aim of assisting in the decisions about upgrading in production. The paper explores several ways in which technical lag can be implemented, depending on requirements. As an illustration, it presents as well some specific cases in which the evolution of technical lag is computed.},
	isbn = {978-3-319-57735-7},
	issn = {1868-422X},
	doi = {10.1007/978-3-319-57735-7_17},
	url = {https://link.springer.com/chapter/10.1007/978-3-319-57735-7_17},
	author = {Gonz{\'a}lez-Barahona, J.M. and Sherwood, P. and Robles, G. and Izquierdo, D.},
	editor = {Balaguer, Federico and Di Cosmo, Roberto and Garrido, Alejandra and Kon, Fabio and Gregorio Robles and Zacchiroli, Stefano}
}
@article {1861,
	title = {The Debsources Dataset: two decades of free and open source software},
	journal = {Empirical Software Engineering},
	year = {2016},
	month = {05/2015},
	publisher = {IEEE},
	abstract = {We present the Debsources Dataset: distribution metadata and source code metrics spanning two decades of Free and Open Source Software (FOSS) history, seen through the lens of the Debian distribution. Debsources is a software platform used to gather, search, and publish on the Web the full source code of the Debian operating system, as well as measures about it. A notable public instance of Debsources is available at http://sources.debian.net, it includes both current and historical releases of Debian. Plugins to compute popular source code metrics (lines of code, defined symbols, disk usage) and other derived data (e.g., Checksums) have been written, integrated, and run on all the source code available on sources.debian.net. The Debsources Dataset is a PostgreSQL database dump of sources.debian.net metadata, as of February 10th, 2015. The dataset contains both Debian-specific metadata -- e.g., which software packages are available in which release, which source code file belong to which package, release dates, etc. -- and source code information gathered by running Debsources plugins. The Debsources Dataset offer a very long-term historical view of the macro-level evolution and constitution of FOSS through the lens of popular, representative FOSS projects of their times.},
	keywords = {debian, metadata, postgresql},
	issn = {1573-7616},
	doi = {10.1007/s10664-016-9461-5},
	url = {https://matthieu.io/dl/papers/debsources-ese-2016.pdf},
	author = {Caneill, Matthieu and Daniel M. Germ{\'a}n and Zacchiroli, Stefano}
}
@conference {VGZ15,
	title = {Automatically Prioritizing Pull Requests},
	booktitle = {Proceedings of the 12th International Conference on Mining Software Repositories},
	year = {2015},
	month = {05/2015},
	publisher = {IEEE},
	organization = {IEEE},
	abstract = {In previous work, we observed that in the pull-based
development model integrators face challenges with regard to prioritizing
work in the face of multiple concurrent pull requests. We
present the design and initial implementation of a prototype pull
request prioritisation tool called PRioritizer. PRioritizer works
like a priority inbox for pull requests, recommending the top pull
requests the project owner should focus on. A preliminary user
study showed that PRioritizer provides functionality that GitHub
is currently lacking, even though users need more insight into
how the priority ranking is established to make PRioritizer really
useful.},
	url = {http://www.gousios.gr/pub/prioritizer.pdf},
	attachments = {https://flosshub.org/sites/flosshub.org/files/prioritizer.pdf},
	author = {van der Veen, Erik and Gousios, Georgios and Zaidman, Andy}
}
@proceedings {1757,
	title = {The Debsources Dataset: Two Decades of Debian Source Code Metadata},
	year = {2015},
	month = {05/2015},
	publisher = {IEEE},
	abstract = {We present the Debsources Dataset: distribution
metadata and source code metrics spanning two decades of Free
and Open Source Software (FOSS) history, seen through the lens
of the Debian distribution.
Debsources is a software platform used to gather, search, and
publish on the Web the full source code of the Debian operating
system, as well as measures about it. A notable public instance
of Debsources is available at http://sources.debian.net; it includes
both current and historical releases of Debian. Plugins to compute
popular source code metrics (lines of code, defined symbols,
disk usage) and other derived data (e.g., checksums) have been
written, integrated, and run on all the source code available on
sources.debian.net.
The Debsources Dataset is a PostgreSQL database dump
of sources.debian.net metadata, as of February 10th, 2015.
The dataset contains both Debian-specific metadata{\textemdash}e.g., which
software packages are available in which release, which source
code file belong to which package, release dates, etc.{\textemdash}and source
code information gathered by running Debsources plugins.
The Debsources Dataset offer a very long-term historical view
of the macro-level evolution and constitution of FOSS through
the lens of popular, representative FOSS projects of their times.},
	keywords = {debian},
	url = {https://upsilon.cc/~zack/research/publications/debsources-msr-2015.pdf},
	attachments = {https://flosshub.org/sites/flosshub.org/files/debsources-msr-2015.pdf},
	author = {Zacchiroli, Stefano}
}
@conference {1795,
	title = {An Empirical Study of Developer Quality},
	booktitle = {2015 International Conference on Software Quality, Reliability and Security - Companion (QRS-C)},
	year = {2015},
	month = {08/2015},
	pages = {202 - 209},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Vancouver, BC, Canada},
	abstract = {Human factors have attracted more and more attention in software engineering. Of many kinds of developer metrics proposed, developer quality is important. Recently, some researchers measure a developer{\textquoteright}s quality as the rate of his/hernon bug-introducing commits. In this paper, we conduct an empirical study of this developer quality metric. We use the data of six open source software projects and get the following conclusions: (1) the values of developer quality in a project are uniformly distributed in a certain range, (2) developer quality tends to increase with software evolution, (3) developers with more contribution are more likely to have higher developer quality, (4) ownership does not have a consistent and significant correlation with developer quality. These results can provide project leaders and team members with some guides to improve developer quality, and thus improve software quality.},
	doi = {10.1109/QRS-C.2015.33},
	author = {Qiu, Yilin and Zhang, Weiqiang and Zou, Weiqin and Liu, Jia and Liu, Qin}
}
@conference {1822,
	title = {An Empirical Study of Developer Quality},
	booktitle = {2015 International Conference on Software Quality, Reliability and Security - Companion (QRS-C)},
	year = {2015},
	pages = {202 - 209},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Vancouver, BC, Canada},
	abstract = {Human factors have attracted more and more attention in software engineering. Of many kinds of developer metrics proposed, developer quality is important. Recently, some researchers measure a developer{\textquoteright}s quality as the rate of his/hernon bug-introducing commits. In this paper, we conduct an empirical study of this developer quality metric. We use the data of six open source software projects and get the following conclusions: (1) the values of developer quality in a project are uniformly distributed in a certain range, (2) developer quality tends to increase with software evolution, (3) developers with more contribution are more likely to have higher developer quality, (4) ownership does not have a consistent and significant correlation with developer quality. These results can provide project leaders and team members with some guides to improve developer quality, and thus improve software quality.
},
	doi = {10.1109/QRS-C.2015.33},
	author = {Qiu, Yilin and Zhang, Weiqiang and Zou, Weiqin and Liu, Jia and Liu, Qin}
}
@proceedings {1748,
	title = {Mining Component Repositories for Installability Issues},
	year = {2015},
	month = {05/2015},
	abstract = {Component repositories play an increasingly relevant
role in software life-cycle management, from software
distribution to end-user, to deployment and upgrade management.
Software components shipped via such repositories are
equipped with rich metadata that describe their relationship (e.g.,
dependencies and conflicts) with other components.
In this practice paper we show how to use a tool, distcheck,
that uses component metadata to identify all the components in
a repository that cannot be installed (e.g., due to unsatisfiable
dependencies), provides detailed information to help developers
understanding the cause of the problem, and fix it in the
repository.
We report about detailed analyses of several repositories: the
Debian distribution, the OPAM package collection, and Drupal
modules. In each case, distcheck is able to efficiently identify not
installable components and provide valuable explanations of the
issues. Our experience provides solid ground for generalizing the
use of distcheck to other component repositories.},
	keywords = {drupal, opam},
	url = {http://www.dicosmo.org/preprints/msr-2015-distcheck.pdf},
	attachments = {https://flosshub.org/sites/flosshub.org/files/msr-2015-distcheck.pdf},
	author = {Abate, Pietro and Di Cosmo, Roberto and Gesbert, Louis and Fabrice Le Fessant and Ralf Treinen and Zacchiroli, Stefano}
}
@conference {1859,
	title = {OSSEAN: Mining Crowd Wisdom in Open Source Communities},
	booktitle = {2015 IEEE Symposium on Service-Oriented System Engineering (SOSE)},
	year = {2015},
	pages = {367 - 371},
	publisher = {IEEE},
	organization = {IEEE},
	address = {San Francisco Bay, CA, USA},
	abstract = {Nowadays open source software represents a successful crowd-based software production model and is becoming an ecosystem combining huge amounts of software producers (such as software developers) and consumers (such as software users and customers). Lots of research work has been conducted on analyzing software artifacts created by producers, but few of them reveal the power of feedback from consumers which we believe is very important for the evaluation and evolution of open source software. This paper introduces OSSEAN, a platform for Open Source Software Evaluating, Analyzing and Networking. OSSEAN divides the open source communities into two groups: software production communities and software consumption communities. The former contain structured software artifacts such as projects, source code and issues, while the latter are full of textual documents with rich semantics of user feedback. We show the power of OSSEAN with some interesting demos by analyzing more than 200 thousands of open source projects and 10 million documents.},
	keywords = {flossmole},
	doi = {10.1109/SOSE.2015.51},
	author = {Yin, Gang and Wang, Tao and Wang, Huaimin and Fan, Qiang and Zhang, Yang and Yu, Yue and Yang, Cheng}
}
@proceedings {export:232407,
	title = {The Uniqueness of Changes: Characteristics and Applications},
	year = {2015},
	month = {05/2015},
	abstract = {Changes in software development come in many forms. Some changes are frequent, idiomatic, or repetitive (e.g. adding checks for nulls or logging important values) while others are unique. We hypothesize that unique changes are different from the more common similar (or non-unique) changes in important ways; they may require more expertise or represent code that is more complex or prone to mistakes. As such, these changes are worthy of study. In this paper, we present a definition of unique changes and provide a method for identifying them in software project history. Based on the results of applying our technique on the Linux kernel and two large projects at Microsoft, we present an empirical study of unique changes. We explore how prevalent unique changes are and characterize where they occur along the architecture of the project. We further investigate developers{\textquoteright} contribution towards uniqueness of changes. We also describe potential applications of leveraging the uniqueness of change and implement two such applications, evaluating the risk of changes based on uniqueness and providing change recommendations for non-unique changes.},
	keywords = {linux kernel},
	url = {http://research.microsoft.com/apps/pubs/default.aspx?id=232407},
	attachments = {https://flosshub.org/sites/flosshub.org/files/MSR-TR-2014-149.pdf},
	author = {Ray, Baishakhi and Meiyappan Nagappan and Christian Bird and Nachiappan Nagappan and Zimmermann, Thomas}
}
@conference {zanjani2015developer,
	title = {Using Developer-Interaction Trails to Triage Change Requests},
	booktitle = {12th Working Conference on Mining Software Repositories (MSR 2015)},
	year = {2015},
	month = {05/2015},
	publisher = {IEEE},
	organization = {IEEE},
	abstract = {The paper presents an approach, namely iHDev, to recommend developers who are most likely to implement incoming change requests. The basic premise of iHDev is that the developers who interacted with the source code relevant to a given change request are most likely to best assist with its resolution. A machine-learning technique is first used to locate source-code entities relevant to the textual description of a given change request. iHDev then mines interaction trails (i.e., Mylyn sessions) associated with these source-code entities to recommend a ranked list of developers. iHDev integrates the interaction trails in a unique way to perform its task, which was not investigated previously. 
An empirical study on open source systems Mylyn and Eclipse Project was conducted to assess the effectiveness of iHDev. A number of change requests were used in the evaluated benchmark. Recall for top one to five recommended developers and Mean Reciprocal Rank (MRR) values are reported. Furthermore, a comparative study with two previous approaches that use commit histories and/or the source-code authorship information for developer recommendation was performed. Results show that iHDev could provide a recall gain of up to 127.27\% with equivalent or improved MRR values by up to 112.5\%.},
	url = {http://www.cabird.com/wp/zanjani2015developer/},
	attachments = {https://flosshub.org/sites/flosshub.org/files/zanjani2015developer.pdf},
	author = {Motahareh Bahrami Zanjani and Kagdi, Huzefa and Christian Bird}
}
@conference {Gousios:2014:DPD:2597073.2597122,
	title = {A Dataset for Pull-based Development Research},
	booktitle = {Proceedings of the 11th Working Conference on Mining Software Repositories},
	series = {MSR 2014},
	year = {2014},
	pages = {368{\textendash}371},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {Pull requests form a new method for collaborating in distributed software development. To study the pull request distributed development model, we constructed a dataset of almost 900 projects and 350,000 pull requests, including some of the largest users of pull requests on Github. In this paper, we describe how the project selection was done, we analyze the selected features and present a machine learning tool set for the R statistics environment.
},
	keywords = {Distributed software development, Empirical software engineering, msr data showcase, pull request, pull-based development},
	isbn = {978-1-4503-2863-0},
	doi = {10.1145/2597073.2597122},
	url = {http://doi.acm.org/10.1145/2597073.2597122},
	attachments = {https://flosshub.org/sites/flosshub.org/files/pullreqs-dataset.pdf},
	author = {Gousios, Georgios and Zaidman, Andy}
}
@conference {Zhang:2014:ISM:2666539.2666572,
	title = {Investigating Social Media in GitHub{\textquoteright}s Pull-requests: A Case Study on Ruby on Rails},
	booktitle = {Proceedings of the 1st International Workshop on Crowd-based Software Development Methods and Technologies},
	series = {CrowdSoft 2014},
	year = {2014},
	pages = {37{\textendash}41},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {In GitHub, pull-request mechanism is an outstanding social development method by integrating with many social media. Many studies have explored that social media has an important effect on software development. @-mention as a typical social media, is a useful tool in social platform. In this paper, we made a quantitative analysis of @-mention in pull-requests of the project Ruby on Rails. First, we make a convictive statistics of the popularity of pull-request mechanism in GitHub. Then we investigate the current situation of @-mention in the Ruby on Rails. Our empirical analysis results find some insights of @-mention.
},
	keywords = {@-mention, github, pull-request, social media},
	isbn = {978-1-4503-3224-8},
	doi = {10.1145/2666539.2666572},
	url = {http://doi.acm.org/10.1145/2666539.2666572},
	author = {Zhang, Yang and Yin, Gang and Yu, Yue and Wang, Huaimin}
}
@conference {Gousios:2014:LGG:2597073.2597126,
	title = {Lean GHTorrent: GitHub Data on Demand},
	booktitle = {Proceedings of the 11th Working Conference on Mining Software Repositories},
	series = {MSR 2014},
	year = {2014},
	pages = {384{\textendash}387},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {In recent years, GitHub has become the largest code host in the world, with more than 5M developers collaborating across 10M repositories. Numerous popular open source projects (such as Ruby on Rails, Homebrew, Bootstrap, Django or jQuery) have chosen GitHub as their host and have migrated their code base to it. GitHub offers a tremendous research potential. For instance, it is a flagship for current open source development, a place for developers to showcase their expertise to peers or potential recruiters, and the platform where social coding features or pull requests emerged. However, GitHub data is, to date, largely underexplored. To facilitate studies of GitHub, we have created GHTorrent, a scalable, queriable, offline mirror of the data offered through the GitHub REST API. In this paper we present a novel feature of GHTorrent designed to offer customisable data dumps on demand. The new GHTorrent data-on-demand service offers users the possibility to request via a web form up-to-date GHTorrent data dumps for any collection of GitHub repositories. We hope that by offering customisable GHTorrent data dumps we will not only lower the "barrier for entry" even further for researchers interested in mining GitHub data (thus encourage researchers to intensify their mining efforts), but also enhance the replicability of GitHub studies (since a snapshot of the data on which the results were obtained can now easily accompany each study).
},
	keywords = {data on demand, dataset, github, msr data showcase},
	isbn = {978-1-4503-2863-0},
	doi = {10.1145/2597073.2597126},
	url = {http://doi.acm.org/10.1145/2597073.2597126},
	attachments = {https://flosshub.org/sites/flosshub.org/files/lean-ghtorrent_0.pdf},
	author = {Gousios, Georgios and Vasilescu, Bogdan and Serebrenik, Alexander and Zaidman, Andy}
}
@conference {1823,
	title = {"May the fork be with you": novel metrics to analyze collaboration on GitHub},
	booktitle = {Proceedings of the 5th International Workshop on Emerging Trends in Software Metrics - WETSoM 2014},
	year = {2014},
	note = {"According to FLOSSmole [8] (Free Libre OpenSource Software)
statistics, GitHub had 191765 repositories publicly
available at May 2012."},
	pages = {37 - 43},
	publisher = {ACM Press},
	organization = {ACM Press},
	address = {New York, New York, USA},
	abstract = {Multi{\textendash}repository software projects are becoming more and
more popular, thanks to web{\textendash}based facilities such as GitHub.
Code and process metrics generally assume a single repository
must be analyzed, in order to measure the characteristics
of a codebase. Thus they are not apt to measure how
much relevant information is hosted in multiple repositories
contributing to the same codebase. Nor can they feature
the characteristics of such a distributed development process.
We present a set of novel metrics, based on an original
classification of commits, conceived to capture some interesting
aspects of a multi{\textendash}repository development process. We
also describe an efficient way to build a data structure that
allows to compute these metrics on a set of Git repositories.
Interesting outcomes, obtained by applying our metrics
on a large sample of projects hosted on GitHub, show the
usefulness of our contribution.},
	keywords = {flossmole, github},
	isbn = {9781450328548},
	doi = {10.1145/2593868.2593875},
	url = {http://marbiaz.github.io/docs/Biazzini14b.pdf},
	author = {Marco Biazzini and Benoit Baudry}
}
@conference {Beller:2014:MCR:2597073.2597082,
	title = {Modern Code Reviews in Open-source Projects: Which Problems Do They Fix?},
	booktitle = {Proceedings of the 11th Working Conference on Mining Software Repositories},
	series = {MSR 2014},
	year = {2014},
	pages = {202{\textendash}211},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {Code review is the manual assessment of source code by humans, mainly intended to identify defects and quality problems. Modern Code Review (MCR), a lightweight variant of the code inspections investigated since the 1970s, prevails today both in industry and open-source software (OSS) systems. The objective of this paper is to increase our understanding of the practical benefits that the MCR process produces on reviewed source code. To that end, we empirically explore the problems fixed through MCR in OSS systems. We manually classified over 1,400 changes taking place in reviewed code from two OSS projects into a validated categorization scheme. Surprisingly, results show that the types of changes due to the MCR process in OSS are strikingly similar to those in the industry and academic systems from literature, featuring the similar 75:25 ratio of maintainability-related to functional problems. We also reveal that 7{\textendash}35\% of review comments are discarded and that 10{\textendash}22\% of the changes are not triggered by an explicit review comment. Patterns emerged in the review data; we investigated them revealing the technical factors that influence the number of changes due to the MCR process. We found that bug-fixing tasks lead to fewer changes and tasks with more altered files and a higher code churn have more changes. Contrary to intuition, the person of the reviewer had no impact on the number of changes.
},
	keywords = {code review, defects, open source software},
	isbn = {978-1-4503-2863-0},
	doi = {10.1145/2597073.2597082},
	url = {http://doi.acm.org/10.1145/2597073.2597082},
	attachments = {https://flosshub.org/sites/flosshub.org/files/beller.pdf},
	author = {Beller, Moritz and Bacchelli, Alberto and Zaidman, Andy and Juergens, Elmar}
}
@conference {1687,
	title = {Recommending relevant projects via user behaviour: an exploratory study on github},
	booktitle = {Proceedings of the 1st International Workshop on Crowd-based Software Development Methods and Technologies - CrowdSoft 2014},
	year = {2014},
	pages = {25 - 30},
	publisher = {ACM Press},
	organization = {ACM Press},
	address = {Hong Kong, ChinaNew York, New York, USA},
	abstract = {Social coding sites (e.g., Github) provide various features like Forking and Sending Pull-requests to support crowd-based software engineering. When using these features, a large amount of user behavior data is recorded. User behavior data can reflect developers preferences and interests in software development activities. Online service providers in many fields have been using user behavior data to discover user preferences and interests to achieve various purposes. In the field of software engineering however, there has been few studies in mining large amount of user behavior data. Our goal is to design an approach based on user behavior data, to recommend relevant open source projects to developers, which can be helpful in activities like searching for the right open source solutions to quickly build prototypes. In this paper, we explore the possibilities of such a method by conducting a set of experiments on selected data sets from Github. We find it a promising direction in mining projects{\textquoteright} relevance from user behavior data. Our study also obtain some important issues that is worth considering in this method.},
	isbn = {9781450332248},
	doi = {10.1145/2666539.2666570},
	url = {http://dl.acm.org/citation.cfm?id=2666570},
	author = {Zhang, Lingxiao and Yanzhen Zou and Bing Xie and Zixiao Zhu}
}
@proceedings {1505,
	title = {An Empirical Study of the Fault-Proneness of Clone Mutation and Clone Migration },
	year = {2013},
	month = {05/2013},
	abstract = {When implementing new features into a software system, developers may duplicate several lines of code to reuse some existing code segments. This action creates code clones in the software system. The literature has documented different types of code clone (e.g., Type-1, Type-2, and Type-3). Once created, code clones evolve as they are modified during both the development and maintenance phases of the software system. The evolution of code clones across the revisions of a software system is known as a clone genealogy. Existing work has investigated the fault-proneness of Type-1 and Type-2 clone genealogies. In this study, we investigate clone genealogies containing Type-3 clones. We analyze three long lived software systems APACHE-ANT, ARGOUML, and JBOSS, which are all written in JAVA. Using the NICAD clone detection tool, we build clone genealogies and examine two evolutionary phenomena on clones: the mutation of the type of a clone during the evolution of a system, and the migration of clone segments across the repositories of a software system. Results show that 1) mutation and migration occur frequently in software systems; 2) the mutation of a clone group to Type-2 or Type-3 clones increases the risk for faults; 3) increasing the distance between code segments in a clone group also increases the risk for faults. Index Terms: Types of clones; clone genealogy; clone migration; fault-proneness.},
	author = {Shuai Xie and Foutse Khomh and Ying Zou}
}
@conference {zmzkh-icsm-2013,
	title = {How does Context affect the Distribution of Software Maintainability Metrics?},
	booktitle = {Proceedings of the 29th IEEE International Conference on Software Maintainability},
	series = {ICSM {\textquoteright}13},
	year = {2013},
	note = {"FLOSSMole [25] is another data source, from
where we download descriptions (i.e., application domain)
of SourceForge software systems. Furthermore, we download
latest application domain information4
and monthly download
data5 of studied software systems directly from SourceForge."},
	abstract = {Software metrics have many uses, e.g., defect prediction, effort estimation, and benchmarking an organization against peers and industry standards. In all these cases, metrics may depend on the context, such as the programming language. Here we aim to investigate if the distributions of commonly used metrics do, in fact, vary with six context factors: application domain, programming language, age, lifespan, the number of changes, and the number of downloads. For this preliminary study we select 320 nontrivial software systems from SourceForge. These software systems are randomly sampled from nine popular application domains of SourceForge. We calculate 39 metrics commonly used to assess software maintainability for each software system and use Kruskal Wallis test and Mann-Whitney U test to determine if there are significant differences among the distributions with respect to each of the six context factors. We use Cliff{\textquoteright}s delta to measure the magnitude of the differences and find that all six context factors affect the distribution of 20 metrics and the programming language factor affects 35 metrics. We also briefly discuss how each context factor may affect the distribution of metric values.We expect our results to help software benchmarking and other software engineering methods that rely on these commonly used metrics to be tailored to a particular context.},
	keywords = {benchmark, context, contextual factor, flossmole, large scale, metrics, mining software repositories, sampling, software maintainability, sourceforge, static metrics},
	attachments = {https://flosshub.org/sites/flosshub.org/files/icsm2013_contextstudy.pdf},
	author = {Zhang, Feng and Audris Mockus and Ying Zou and Foutse Khomh and Hassan, Ahmed E.}
}
@proceedings {1501,
	title = {The Impact of Tangled Code Changes},
	year = {2013},
	month = {05/2013},
	abstract = {When interacting with version control systems, developers often commit unrelated or loosely related code changes
in a single transaction. When analyzing the version history, such
tangled changes will make all changes to all modules appear
related, possibly compromising the resulting analyses through
noise and bias. In an investigation of five open-source JAVA
projects, we found up to 15\% of all bug fixes to consist of multiple
tangled changes. Using a multi-predictor approach to untangle
changes, we show that on average at least 16.6\% of all source
files are incorrectly associated with bug reports. We recommend
better change organization to limit the impact of tangled changes.},
	keywords = {bias, data quality, history, java, mining software repositories, noise, tangled code changes, version control},
	url = {http://www.kim-herzig.de/wp-content/uploads/2013/03/msr2013-untangling.pdf},
	attachments = {https://flosshub.org/sites/flosshub.org/files/msr2013-untangling.pdf},
	author = {Kim Herzig and Zeller, Andreas}
}
@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 {1521,
	title = {It{\textquoteright}s Not a Bug, It{\textquoteright}s a Feature: How Misclassification Impacts Bug Prediction},
	year = {2013},
	month = {05/2013},
	pages = {392-401},
	abstract = {In a manual examination of more than 7,000 issue reports from the bug databases of five open-source projects, we found 33.8\% of all bug reports to be misclassified{\textemdash}that is, rather than referring to a code fix, they resulted in a new feature, an update to documentation, or an internal refactoring. This misclassification introduces bias in bug prediction models, confusing bugs and features: On average, 39\% of files marked as defective actually never had a bug. We discuss the impact of this misclassification on earlier studies and recommend manual data validation for future studies.},
	keywords = {bias, bug reports, data quality, mining software repositories, noise},
	author = {Kim Herzig and Sascha Just and Zeller, Andreas}
}
@proceedings {1557,
	title = {"Release Early, Release Often"? An Empirical Analysis of Release Strategy in Open Source Software Co-Creation},
	year = {2013},
	abstract = {{\textquotedblleft}Release early, release often{\textquotedblright} is becoming a popular new product introduction strategy in open source software development. We study the influence of release strategies on the download market share of open source projects. Using a panel data set collected from Sourceforge.net, we find that while more frequent releases are associated with better subsequent download market share, the relationship is curvilinear. Too frequent releases could backfire due to the subtle effects on the demand and supply sides of open source software production. From the demand side, we find that releasing frequently may work less effectively in projects with higher adoption costs. From the supply side, fast releases may work less effectively in projects with weak community contributions. Even when the community contributions are strong, the restrictiveness of open source license moderates the effectiveness of releasing early and often. These results have implications for managing open source projects and research on open source software, open innovation, and software adoption.},
	url = {http://aisel.aisnet.org/pacis2013/11},
	attachments = {https://flosshub.org/sites/flosshub.org/files/PACIS2013-002.pdf},
	author = {Chen, Wei and Krishnan, Vish and Zhu, Kevin}
}
@conference {1576,
	title = {A scalable crawler framework for FLOSS data},
	booktitle = {Proceedings of the 5th Asia-Pacific Symposium on Internetware - Internetware {\textquoteright}13},
	year = {2013},
	note = {FLOSSmole [8] and FLOSSmetrics [9] retrieved FLOSS data of
various types from famous software forges like SourceForge and
Google code, interface to data sharing and analyzing is also
provided. 

" Typically,
Howison et al. [8] proposed a system called FLOSSmole.
FLOSSmole is a large collection of datasets extracted from
famous software forges such as SourceForge, GitHub, and Google
Code. Datasets in FLOSSmole are mainly metadata describing
various facts about the development of FLOSS projects.
FLOSSmole manages its datasets in an open and collaborative
manner. Most of the data is collected by the FLOSSmole research
team, yet they also accept data donation from other research
groups or similar projects. The scripts and programs that collects
the datasets from the Internet is also open for download and
donation. "

"Using
FLOSSmole [8] and FLOSSmetrics [9] as case studies, similar
systems as such are called {\textquotedblleft}repository of repositories (RoR){\textquotedblright} and
basic requirements of these systems are proposed. "},
	pages = {1 - 7},
	publisher = {ACM Press},
	organization = {ACM Press},
	address = {Changsha, China},
	abstract = {Free / Libre / Open Source Software (FLOSS) data, such as bug reports, mailing lists and related webpages, contains valuable information for reusing open source software projects. Before conducting further experiment on FLOSS data, researchers often need to download these data into a local storage system. We refer to this pre-process as FLOSS data retrieval, which in many cases can be a challenging task. In this paper, we proposed a crawler framework to ease the process of FLOSS data retrieval. To cope with various types of FLOSS data scattered on the Internet, we designed the framework in a scalable manner where a crawler program can be easily plugged into the system to extend its functionality. Researchers can perform the retrieval process on datasets of various types and sources simply by adding new configurations to the system. We have implemented the framework and provided basic functions via web-based interfaces. We presented the usage of the system by a detailed case study where we retrieved various types of datasets related to Apache Lucene project using our framework.},
	keywords = {flossmole cited},
	isbn = {9781450323697},
	doi = {10.1145/2532443.2532454},
	author = {Yanzhen Zou and Bing Zie and Zhang, Lingxiao}
}
@proceedings {1443,
	title = {Citizen Engineering: Evolving OSS Practices to Engineering Design and Analysis},
	volume = {378},
	year = {2012},
	month = {09/2012},
	pages = {61-77},
	publisher = {IFIP AICT},
	abstract = {Open Source Software (OSS) development has much in common with concepts such as crowdsourcing, citizen science, collective intelligence, human-based computation, and what we call {\textquotedblleft}Citizen Engineering (CE){\textquotedblright}. We report on several pilot projects that apply these shared principles of OSS development to engineering activities beyond software engineering. CE models harness human computing power from open communities, which commonly consist of a cohort of geographically and/or institutionally scattered citizens - professionals or amateurs - to collaboratively solve real-world problems. In most cases, the problems targeted are challenging to computers, but manageable or trivial to human intelligence. In these systems, while humans play fundamental roles, whether they are project architects or problem solvers, the implementation of CE is greatly facilitated by the advance of information technology, particularly the Internet, considered as "creative mode of user interactivity, not merely a medium between messages and people" [10]. In this paper, we characterize existing citizen engineering practices into 6 major categories, followed by a discussion of 4 ongoing projects, aiming to provide new perspectives and insights for achieving successful CE project designs.},
	author = {Zhai, Zhi and Kijewski-Correa, Tracy and Kareem, Ashan and Hachen, David and Madey, Gregory}
}
@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 {1309,
	title = {Do time of day and developer experience affect commit bugginess},
	booktitle = {Proceedings of the 8th working conference on Mining software repositories - MSR {\textquoteright}11},
	year = {2011},
	note = {"we study the latest versions of the Linux kernel and PostgreSQL, which have 222,332 and 31,098 commits, respectively. We study the correlation between a commit{\textquoteright}s bugginess and the time of day of the commit, the day of week of the commit, and the experience and commit frequency of the commit authors. In addition, we study several other commit characteristics, such as comment-only fixes and bug lifetimes."},
	month = {05/2011},
	pages = {153-162},
	publisher = {ACM Press},
	organization = {ACM Press},
	address = {New York, New York, USA},
	abstract = {Modern software is often developed over many years with hundreds of thousands of commits. Commit metadata is a rich source of social characteristics, including the commit{\textquoteright}s time of day and the experience and commit frequency of its author. The "bugginess" of a commit is also a critical property of that commit. In this paper, we investigate the correlation between a commit{\textquoteright}s social characteristics and its "bugginess"; such results can be very useful for software developers and software engineering researchers. For instance, developers or code reviewers might be well-advised to thoroughly verify commits that are more likely to be buggy. In this paper, we study the correlation between a commit{\textquoteright}s bugginess and the time of day of the commit, the day of week of the commit, and the experience and commit frequency of the commit authors. We survey two widely-used open source projects: the Linux kernel and PostgreSQL.

Our main findings include: (1) commits submitted between midnight and 4 AM (referred to as late-night commits) are significantly buggier and commits between 7 AM and noon are less buggy, implying that developers may want to double-check their own latenight commits; (2) daily-committing developers produce less-buggy commits, indicating that we may want to promote the practice of daily-committing developers reviewing other developers{\textquoteright} commits; and (3) the bugginess of commits versus day-of-week varies for different software projects.},
	isbn = {9781450305747},
	doi = {10.1145/1985441.1985464},
	author = {Tan, Lin and Lam, Patrick and Eyolfson, Jon}
}
@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 {1306,
	title = {Java generics adoption},
	booktitle = {Proceedings of the 8th working conference on Mining software repositories - MSR {\textquoteright}11},
	year = {2011},
	note = {"we automatically analyzed 20 open source software projects. We analyzed the top {\textquotedblleft}most used{\textquotedblright} projects according to ohloh.net, including only projects with significant amounts of Java code"

"The 20 selected projects were Ant, Azureus, CheckStyle, Commons Collections, Free- Mind, FindBugs, Jetty, JEdit, JDT, JUnit, Eclipse-cs, Hibernate, Log4j, Lucene, Maven, the Spring Frame- work, Squirrel-SQL, Subclipse, Weka, and Xerces."

"In mining the full version histories of these 20 projects, we analyzed the full content of each version of each Java source file, a total of 548,982,841 lines."},
	month = {05/2011},
	pages = {3-12},
	publisher = {ACM Press},
	organization = {ACM Press},
	address = {New York, New York, USA},
	abstract = {Support for generic programming was added to the Java language in 2004, representing perhaps the most significant change to one of the most widely used programming languages today. Researchers and language designers anticipated this addition would relieve many long-standing problems plaguing developers, but surprisingly, no one has yet measured whether generics actually provide such relief. In this paper, we report on the first empirical investigation into how Java generics have been integrated into open source software by automatically mining the history of 20 popular open source Java programs, traversing more than 500 million lines of code in the process. We evaluate five hypotheses, each based on assertions made by prior researchers, about how Java developers use generics. For example, our results suggest that generics do not significantly reduce the number of type casts and that generics are usually adopted by a single champion in a project, rather than all committers.},
	keywords = {commits, generics, java, source code, version history},
	isbn = {9781450305747},
	doi = {10.1145/1985441.1985446},
	author = {Christian Bird and Murphy-Hill, Emerson and Parnin, Chris}
}
@conference {1308,
	title = {Social interactions around cross-system bug fixings},
	booktitle = {Proceedings of the 8th working conference on Mining software repositories - MSR {\textquoteright}11},
	year = {2011},
	note = {"We rely on information stored in versioning database and mailing lists of both systems and develop methods to reconstruct and integrate different historical database"},
	month = {05/2011},
	pages = {143-152},
	publisher = {ACM Press},
	organization = {ACM Press},
	address = {New York, New York, USA},
	abstract = {Cross-system bug fixing propagation is frequent among systems having similar characteristics, using a common framework, or, in general, systems with cloned source code fragments. While previous studies showed that clones tend to be properly maintained within a single system, very little is known about cross-system bug management.

This paper describes an approach to mine explicitly documented cross-system bug fixings, and to relate their occurrences to social characteristics of contributors discussing through the project mailing lists--e.g., degree, betweenness, and brokerage--as well as to the contributors{\textquoteright} activity on source code.

The paper reports results of an empirical study carried out on FreeBSD and OpenBSD kernels. The study shows that the phenomenon of cross-system bug fixing between these two projects occurs often, despite the limited overlap of contributors. The study also shows that cross-system bug fixings mainly involve contributors with the highest degree, betweenness and brokerage level, as well as contributors that change the source code more than others.},
	keywords = {bug fixing, bug tracking system, committers, email, email archives, freebsd, mailing list, openbsd},
	isbn = {9781450305747},
	doi = {10.1145/1985441.1985463},
	author = {Cerulo, Luigi and Cimitile, Marta and Di Penta, Massimiliano and Canfora, Gerardo}
}
@conference {1303,
	title = {A study of language usage evolution in open source software},
	booktitle = {Proceedings of the 8th working conference on Mining software repositories - MSR {\textquoteright}11},
	year = {2011},
	month = {05/2011},
	pages = {13-22},
	publisher = {ACM Press},
	organization = {ACM Press},
	address = {Waikiki, Honolulu, HI, USA},
	abstract = {The use of programming languages such as Java and C in Open Source Software (OSS) has been well studied. However, many other popular languages such as XSL or XML have received minor attention. In this paper, we discuss some trends in OSS development that we observed when considering multiple programming language evolution of OSS. Based on the revision data of 22 OSS projects, we tracked the evolution of language usage and other artefacts such as documentation files, binaries and graphics files. In these systems several different languages and artefact types including C/C++, Java, XML, XSL, Makefile, Groovy, HTML, Shell scripts, CSS, Graphics files, JavaScript, JSP, Ruby, Phyton, XQuery, OpenDocument files, PHP, etc. have been used. We found that the amount of code written in different languages differs substantially. Some of our findings can be summarized as follows: (1) JavaScript and CSS files most often co-evolve with XSL; (2) Most Java developers but only every second C/C++ developer work with XML; (3) and more generally, we observed a significant increase of usage of XML and XSL during recent years and found that Java or C are hardly ever the only language used by a developer. In fact, a developer works with more than 5 different artefact types (or 4 different languages) in a project on average.},
	isbn = {9781450305747},
	doi = {10.1145/1985441.1985447},
	author = {Gall, Harald and Karus, Siim}
}
@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 {1312,
	title = {A tale of two browsers},
	booktitle = {Proceedings of the 8th working conference on Mining software repositories - MSR {\textquoteright}11},
	year = {2011},
	month = {05/2011},
	pages = {238-241},
	publisher = {ACM Press},
	organization = {ACM Press},
	address = {New York, New York, USA},
	abstract = {We explore the space of open source systems and their user communities by examining the development artifact histories of two popular web browsers -- Firefox and Chrome -- as well as usage data. By examining the data and addressing a number of research questions, two very different profiles emerge: Firefox, as the older and established system, with long product version cycles but short bug fix cycles, and a user base that is slow to adopt newer versions; and Chrome, as the new and fast evolving system, with short version cycles, longer bug fix cycles, and a user base that very quickly adopts new versions as they become available (due largely to Chrome{\textquoteright}s mandatory automatic updates).

},
	keywords = {chrome, development history, Firefox, msr challenge},
	isbn = {9781450305747},
	doi = {10.1145/1985441.1985481},
	author = {Davis, Ian and Godfrey, Michael W. and Baysal, Olga}
}
@conference {1305,
	title = {Visualizing collaboration and influence in the open-source software community},
	booktitle = {Proceedings of the 8th working conference on Mining software repositories - MSR {\textquoteright}11},
	year = {2011},
	note = {"This data set includes the complete social graph of 500,000 follow links as well as over 1,000,000 commits and 50,000 users."

"...a large fraction of [GitHub] users provide a location in their profile, which we can turn into geographic coordinates using a geocoding API like PlaceFinder...

"For each repository, we extract the owner, collaborator, and contributor usernames, plus branch names. New user- names help to find new repositories, while branch names are used to fetch commit metadata. Using this method, the crawler uncovered 40,860 code repositories, representing 33,388 unique project names and 1,219,872 individual commits."

"In addition to crawled data, we use the complete GitHub user follower graph from Jan 19, 2011. This graph includes 452,248 links connecting 106,247 unique users, 47\% (49,500) of which could be geocoded with the PlaceFinder API"},
	month = {05/2011},
	pages = {223-226},
	publisher = {ACM Press},
	organization = {ACM Press},
	address = {New York, New York, USA},
	abstract = {We apply visualization techniques to user profiles and repository metadata from the GitHub source code hosting service. Our motivation is to identify patterns within this development community that might otherwise remain obscured. Such patterns include the effect of geographic distance on developer relationships, social connectivity and influence among cities, and variation in project-specific contribution styles (e.g., centralized vs. distributed). Our analysis examines directed graphs in which nodes represent users{\textquoteright} geographic locations and edges represent (a) follower relationships, (b) successive commits, or (c) contributions to the same project. We inspect this data using a set of visualization techniques: geo-scatter maps, small multiple displays, and matrix diagrams. Using these representations, and tools based on them, we develop hypotheses about the larger GitHub community that would be difficult to discern using traditional lists, tables, or descriptive statistics. These methods are not intended to provide conclusive answers; instead, they provide a way for researchers to explore the question space and communicate initial insights.},
	keywords = {COLLABORATION, data exploration, geography, geoscatter, github, graph, mapping, metadata, open source, social graph, user profiles, visualization},
	isbn = {9781450305747},
	doi = {10.1145/1985441.1985476},
	url = {http://vis.stanford.edu/files/2011-GotHub-MSR.pdf},
	author = {Marschner, Eli and Rosenfeld, Evan and Heer, Jeffrey and Heller, Brandon}
}
@conference {1311,
	title = {What topics do Firefox and Chrome contributors discuss?},
	booktitle = {Proceedings of the 8th working conference on Mining software repositories - MSR {\textquoteright}11},
	year = {2011},
	month = {05/2011},
	pages = {234-237},
	publisher = {ACM Press},
	organization = {ACM Press},
	address = {New York, New York, USA},
	abstract = {Firefox and Chrome are two very popular open source Web browsers, implemented in C/C++. This paper analyzes what topics were discussed in Firefox and Chrome bug reports over time. To this aim, we indexed the text contained in bug reports submitted each semester of the project history, and identified topics using Latent Dirichlet Allocation (LDA). Then, we investigated to what extent Firefox and Chrome developers/contributors discussed similar topics, either in different periods, or over the same period. Results indicate a non-negligible overlap of topics, mainly on issues related to page layouting, user interaction, and multimedia contents.},
	keywords = {bug reports, chrome, Firefox, LDA, msr challenge},
	isbn = {9781450305747},
	doi = {10.1145/1985441.1985480},
	author = {Zagarese, Quirino and Distante, Damiano and Di Penta, Massimiliano and Bernardi, Mario Luca and Sementa, Carmine}
}
@conference {957,
	title = {Assessment of issue handling efficiency},
	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 = {94 - 97},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Cape Town, South Africa},
	abstract = {We mined the issue database of GNOME to assess how issues are handled. How many issues are submitted and resolved? Does the backlog grow or decrease? How fast are issues resolved? Does issue resolution speed increase or decrease over time? In which subproject are issues handled most efficiently? To answer such questions, we apply several visualization and quantification instruments to the raw issue data. In particular, we aggregate issues into four risk categories, based on their resolution time. These categories are the basis both for visualizing and ranking, which are used in concert for issue database exploration.},
	keywords = {bug reports, bug tracking, classification, gnome, msr challenge, visualization},
	isbn = {978-1-4244-6802-7},
	doi = {10.1109/MSR.2010.5463292},
	attachments = {https://flosshub.org/sites/flosshub.org/files/94bluijtenMSR2010.pdf},
	author = {Luijten, Bart and Visser, Joost and Zaidman, Andy}
}
@conference {955,
	title = {Perspectives on bugs in the Debian bug tracking system},
	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 = {86 - 89},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Cape Town, South Africa},
	abstract = {Bugs in Debian differ from regular software bugs. They are usually associated with packages, instead of software modules. They are caused and fixed by source package uploads instead of code commits. The majority are reported by individuals who appear in the bug database once, and only once. There also exists a small group of bug reporters with over 1,000 bug reports each to their name. We also explore our idea that a high bug-frequency for an individual package might be an indicator of popularity instead of poor quality.},
	keywords = {bug reports, debian, msr challenge, popularity},
	isbn = {978-1-4244-6802-7},
	doi = {10.1109/MSR.2010.5463288},
	attachments = {https://flosshub.org/sites/flosshub.org/files/86bugs-debian.pdf},
	author = {Davies, Julius and Hanyu Zhang and Nussbaum, Lucas and Daniel M. German}
}
@conference {952,
	title = {The Ultimate Debian Database: Consolidating bazaar metadata for Quality Assurance and data mining},
	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 = {52 - 61},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Cape Town, South Africa},
	abstract = {FLOSS distributions like RedHat and Ubuntu require a lot more complex infrastructures than most other FLOSS projects. In the case of community-driven distributions like Debian, the development of such an infrastructure is often not very organized, leading to new data sources being added in an impromptu manner while hackers set up new services that gain acceptance in the community. Mixing and matching data is then harder than should be, albeit being badly needed for Quality Assurance and data mining. Massive refactoring and integration is not a viable solution either, due to the constraints imposed by the bazaar development model. This paper presents the Ultimate Debian Database (UDD), which is the countermeasure adopted by the Debian project to the above "data hell". UDD gathers data from various data sources into a single, central SQL database, turning Quality Assurance needs that could not be easily implemented before into simple SQL queries. The paper also discusses the customs that have contributed to the data hell, the lessons learnt while designing UDD, and its applications and potentialities for data mining on FLOSS distributions.},
	keywords = {debian, metadata, udd},
	isbn = {978-1-4244-6802-7},
	doi = {10.1109/MSR.2010.5463277},
	attachments = {https://flosshub.org/sites/flosshub.org/files/52msr2010-udd.pdf},
	author = {Nussbaum, Lucas and Zacchiroli, Stefano}
}
@article {10.1109/TSE.2010.63,
	title = {What Makes a Good Bug Report?},
	journal = {IEEE Transactions on Software Engineering},
	volume = {36},
	year = {2010},
	note = {"o find out which matter most, we asked 872 devel-
opers from the APACHE, ECLIPSE, and MOZILLA projects to:
1. Complete a survey on important information in bug reports and the problems they faced with them. We received a total of 156 responses to our survey (Section 2 and 3).
2. Rate the quality of bug reports from very poor to very good on a five-point Likert scale [22]. We received a total of 1,186 votes for 289 randomly selected bug reports (Section 4).
In addition, we asked 1,354 reporters1 from the same projects to complete a similar survey, out of which 310 responded. "},
	pages = {618-643},
	publisher = {IEEE Computer Society},
	address = {Los Alamitos, CA, USA},
	abstract = {In software development, bug reports provide crucial information to developers. However, these reports widely differ in their quality. We conducted a survey among developers and users of APACHE, ECLIPSE, and MOZILLA to find out what makes a good bug report.
The analysis of the 466 responses revealed an information mis- match between what developers need and what users supply. Most developers consider steps to reproduce, stack traces, and test cases as helpful, which are at the same time most difficult to provide for users. Such insight is helpful to design new bug tracking tools that guide users at collecting and providing more helpful information.
Our CUEZILLA prototype is such a tool and measures the quality of new bug reports; it also recommends which elements should be added to improve the quality. We trained CUEZILLA on a sample of 289 bug reports, rated by developers as part of the survey. In our experiments, CUEZILLA was able to predict the quality of 31{\textendash}48\% of bug reports accurately.},
	keywords = {bug report, Survey},
	issn = {0098-5589},
	doi = {http://doi.ieeecomputersociety.org/10.1109/TSE.2010.63},
	url = {http://dl.acm.org/citation.cfm?id=1453146},
	attachments = {https://flosshub.org/sites/flosshub.org/files/bettenburg-fse-2008.pdf},
	author = {Zimmermann, Thomas and Premraj, Rahul and Bettenburg, Nicolas and Sascha Just and Schroter, Adrian and Weiss, Cathrin}
}
@article {1241,
	title = {Collaborative Software Development Using R-Forge},
	journal = {The R Journal},
	volume = {1},
	number = {1},
	year = {2009},
	month = {05/2009},
	pages = {9-14},
	abstract = {Open source software (OSS) is typically created in a decentralized self-organizing process by a community of developers having the same or similar interests (see the famous essay by Raymond, 1999). A key factor for the success of OSS over the last two decades is the Internet: Developers who rarely meet face-to-face can employ new means of communication, both for rapidly writing and deploying software (in the spirit of Linus Torvald{\textquoteright}s {\textquotedblleft}release early, release often paradigm{\textquotedblright}). Therefore, many tools emerged that assist a collaborative software development process, including in particular tools for source code management (SCM) and version control.
In the R world, SCM is not a new idea; in fact, the R Development Core Team has always been using SCM tools for the R sources, first by means of Concurrent Versions System (CVS, see Cederqvist et al., 2006), and then via Subversion (SVN, see Pilato et al., 2004). A central repository is hosted by ETH Zürich mainly for managing the development of the base R system. Mailing lists like R-help, R-devel and many others are currently the main communication channels in the R community.
First, we present the core features that R- Forge offers to the R community. Second, we give a hands-on tutorial on how users and developers can get started with R-Forge. In particular, we illustrate how people can register, set up new projects, use R- Forge{\textquoteright}s SCM facilities, provide their packages on R-Forge, host a project-specific website, and how package maintainers submit a package to the Compre- hensive R Archive Network (CRAN, http://CRAN. R-project.org/). Finally, we summarize recent developments and give a brief outlook to future work.},
	keywords = {forge, R, scm, source code repositories, statistics},
	attachments = {https://flosshub.org/sites/flosshub.org/files/rjournal.pdf},
	author = {Stefan Theu{\ss}l and Achim Zeileis}
}
@conference {576,
	title = {Providing Commercial Open Source Software: Lessons Learned},
	booktitle = {OSS2009: Open Source Ecosystems: Diverse Communities Interacting (IFIP 2.13)},
	series = {IFIP Advances in Information and Communication Technology },
	volume = {299/2009},
	year = {2009},
	month = {2009///},
	pages = {70 - 82},
	publisher = {Springer},
	organization = {Springer},
	chapter = {8},
	abstract = {Even though companies like Sun, IBM, MySQL and others have released several commercial Open Source Software (OSS) products, little evidence exist of how to successfully launch such products and establish a living community around them. This paper presents a case study from a small software company succeeding at establishing a business model and a vivid community around their own OSS products. Based on this case study, the paper presents lessons learned which could help other OSS providers.
},
	issn = {978-3-642-02031-5},
	doi = {http://dx.doi.org/10.1007/978-3-642-02032-2_8},
	attachments = {https://flosshub.org/sites/flosshub.org/files/Providing\%20Commercial\%20Open\%20Source.pdf},
	author = {Hauge, {\O}yvind and Ziemer, Sven}
}
@article {1350,
	title = {Strategies for Improving Open Source Software Usability},
	journal = {International Journal of Open Source Software and Processes},
	volume = {1},
	year = {2009},
	pages = {49 - 64},
	abstract = {The Open Source Software (OSS) movement has had enormous impact on how software is created and continues to attract interest from researchers, software developers and users. A factor that may be inhibiting OSS from achieving greater success is usability, a fundamental characteristic to user acceptance of software. Motivated by the uniquely user-driven nature of the open source model and the extensive user base that participates in OSS projects, the authors propose an exploratory learning method and an associated web-based inspection environment that enables non-experts to contribute to open source usability inspection. This tool uses patternbased usability guidelines to help identify usability knowledge during inspection. The method emphasizes outlining and exploration features which the authors have formally evaluated and the results of which are described. Data collected from a qualitative study indicates positive impact of the proposed method in helping end-users inspect software and achieve better results in discovering usability problems.},
	issn = {1942-3934},
	doi = {10.4018/jossp.2009100103},
	author = {Zhao, Luyin and Deek, Fadi P. and McHugh, James A.}
}
@conference {938,
	title = {Using association rules to study the co-evolution of production \& test code},
	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 = {151 - 154},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Vancouver, BC, Canada},
	abstract = {Unit tests are generally acknowledged as an important aid to produce high quality code, as they provide quick feedback to developers on the correctness of their code. In order to achieve high quality, well-maintained tests are needed. Ideally, tests co-evolve with the production code to test changes as soon as possible. In this paper, we explore an approach based on association rule mining to determine whether production and test code co-evolve synchronously. Through two case studies, one with an open source and another one with an industrial software system, we show that our association rule mining approach allows one to assess the co-evolution of product and test code in a software project and, moreover, to uncover the distribution of programmer effort over pure coding, pure testing, or a more test-driven-like practice.},
	keywords = {association rules, checkstyle, source code, unit test},
	isbn = {978-1-4244-3493-0},
	doi = {10.1109/MSR.2009.5069493},
	attachments = {https://flosshub.org/sites/flosshub.org/files/151UsingAssociation.pdf},
	author = {Lubsen, Zeeger and Zaidman, Andy and Pinzger, Martin}
}
@conference {Wang:2008:ADD:1368088.1368151,
	title = {An approach to detecting duplicate bug reports using natural language and execution information},
	booktitle = {Proceedings of the 30th international conference on Software engineering},
	series = {ICSE {\textquoteright}08},
	year = {2008},
	pages = {461{\textendash}470},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {An open source project typically maintains an open bug repository so that bug reports from all over the world can be gathered. When a new bug report is submitted to the repository, a person, called a triager, examines whether it is a duplicate of an existing bug report. If it is, the triager marks it as DUPLICATE and the bug report is removed from consideration for further work. In the literature, there are approaches exploiting only natural language information to detect duplicate bug reports. In this paper we present a new approach that further involves execution information. In our approach, when a new bug report arrives, its natural language information and execution information are compared with those of the existing bug reports. Then, a small number of existing bug reports are suggested to the triager as the most similar bug reports to the new bug report. Finally, the triager examines the suggested bug reports to determine whether the new bug report duplicates an existing bug report. We calibrated our approach on a subset of the Eclipse bug repository and evaluated our approach on a subset of the Firefox bug repository. The experimental results show that our approach can detect 67\%-93\% of duplicate bug reports in the Firefox bug repository, compared to 43\%-72\% using natural language information alone.},
	keywords = {bug report, duplicate bug report, execution information, information retrieval, natural language},
	isbn = {978-1-60558-079-1},
	doi = {10.1145/1368088.1368151},
	url = {http://doi.acm.org/10.1145/1368088.1368151},
	author = {Wang, Xiaoyin and Zhang, Lu and Xie, Tao and Anvik, John and Sun, Jiasu}
}
@conference {1815,
	title = {An Exploratory Study on the Evolution of OSS Developer Communities},
	booktitle = {Proceedings of the 41st Annual Hawaii International Conference on System Sciences (HICSS 2008)},
	year = {2008},
	pages = {305 - 305},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Waikoloa, HI, USA},
	abstract = {Software is developed in a dynamic context where team structure, requirements, and processes evolve together with the product. Although researchers have been studying the evolution of software systems since the early 70s, the study on the evolution of software development teams remains rare. Such evolutionary patterns and their impact on software quality are especially important in the context of OSS (Open Source Software) development, where a group of volunteer developers collaborate online for an extended period of time. By analyzing how social networks of developers evolve over time while building OSS products, we can gain knowledge and experience to improve the effectiveness and efficiency of resource management and distribution in future OSS projects. To this end, we studied the evolution of the developer communities using a suite of OSS products developed under the KOffice project. We found that in general, the social networks of OSS developer communities change over time in certain ways. Identifying such patterns can help OSS managers better understand the unique process of OSS development and improve their management and coordination of the projects.
},
	doi = {10.1109/HICSS.2008.58},
	url = {https://www.researchgate.net/publication/221184171_An_Exploratory_Study_on_the_Evolution_of_OSS_Developer_Communities},
	author = {Ngamkajornwiwat, Kawin and Zhang, Dongsong and Koru, A. Gunes and Zhou, Lina and Nolker, and Robert}
}
@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 {643,
	title = {Effect of Coupling on Defect Proneness in Evolutionary Open-Source Software Development},
	booktitle = {OSS2007: Open Source Development, Adoption and Innovation (IFIP 2.13)},
	series = {IFIP International Federation for Information Processing },
	volume = {234/2007},
	year = {2007},
	month = {2007///},
	pages = {271 - 276},
	publisher = {Springer},
	organization = {Springer},
	chapter = {27},
	abstract = {Previous research on closed-source software found that highly coupled software modules were more defect prone, which makes it important to understand the effect of coupling on defect proneness in open-source software (OSS) projects. For this purpose, we used Cox proportional hazards modeling with recurrent events. We found that the effect of coupling was significant, and we quantified this effect on defect proneness.
},
	issn = {978-0-387-72485-0},
	doi = {http://dx.doi.org/10.1007/978-0-387-72486-7_27},
	attachments = {https://flosshub.org/sites/flosshub.org/files/Effect\%20of\%20Coupling\%20on\%20Defect.pdf},
	author = {G{\"u}nes Koru, A. and Zhang, Dongsong and Liu, Hongfang}
}
@booklet {491,
	title = {Free/libre open source software implementation in schools: Evidence from the field and implications for the future},
	year = {2007},
	month = {Sept},
	abstract = {This empirical paper shows how free/libre open source software (FLOSS) contributes to mutual and collaborative learning in an educational environment. Unlike proprietary software, FLOSS allows extensive customisation of software to support the needs of local users better. This also allows users to participate more proactively in the development and implementation process of a FLOSS-based system. In this paper, we observes how implementing FLOSS in an Italian high school challenges the conventional relationship between end users themselves (e.g. teachers and students) and that between users and developers. The findings will shed some light on the social aspects of FLOSS-based computerization - including the role of FLOSS in social and organizational change in educational environments and the ways that the social organization of FLOSS are influenced by social forces and social practices.},
	attachments = {https://flosshub.org/sites/flosshub.org/files/Lin\%26Zini.pdf},
	author = {Yu-wei Lin and Enrico Zini}
}
@inbook {879,
	title = {Free/Open Source Software Development: Recent Research Results and Methods},
	booktitle = { Advances in Computers},
	volume = {69},
	year = {2007},
	pages = {243-295},
	author = {Walt Scacchi},
	editor = {Zelkowitz, M.V.}
}
@article {497,
	title = {The functioning of a free software community: entanglement of three regulation modes - control, autonomous, and distributed},
	journal = {Science Studies},
	number = {2},
	year = {2007},
	abstract = {This paper consider FLOSS communities as ""going concerns"" which necessitate a minimum of order and common, shared, social rules to function. Through an in-depth and diachronic analysis of the Spip project, we present two classical modes of social regulation: a control regulation centred on the product and an autonomous regulation reflecting the differentiated commitments. Our data shows that the meaning, value and legitimacy of contributors{\textquoteright} involvements are defined and rated more collectively, through exchanges, judgments, and evaluations. A third regulation mode, called distributed community regulation and aimed at creating and transforming shared rules that produces recognition and stratification, is then presented.},
	attachments = {https://flosshub.org/sites/flosshub.org/files/Science_Studies_02-2007-Demaziere_Horn_Zune.pdf},
	author = {Didier Demazi{\`e}re and Francois Horn and Marc Zune}
}
@conference {991,
	title = {How Long Will It Take to Fix This Bug?},
	booktitle = {Fourth International Workshop on Mining Software Repositories (MSR{\textquoteright}07:ICSE Workshops 2007)},
	year = {2007},
	pages = {1},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Minneapolis, MN, USA},
	abstract = {Predicting the time and effort for a software problem has long been a difficult task. We present an approach that automatically predicts the fixing effort, i.e., the person-hours spent on fixing an issue. Our technique leverages existing issue tracking systems: given a new issue report, we use the Lucene framework to search for similar, earlier reports and use their average time as a prediction. Our approach thus allows for early effort estimation, helping in assigning issues and scheduling stable releases. We evaluated our approach using effort data from the JBoss project. Given a sufficient number of issues reports, our automatic predictions are close to the actual effort; for issues that are bugs, we are off by only one hour, beating naive predictions by a factor of four.},
	keywords = {bug fixing, bug reports, effort estimation, jboss, lucene, prediction, time},
	isbn = {0-7695-2950-X},
	doi = {10.1109/MSR.2007.13},
	attachments = {https://flosshub.org/sites/flosshub.org/files/28300001.pdf},
	author = {Weiss, Cathrin and Premraj, Rahul and Zimmermann, Thomas and Zeller, Andreas}
}
@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 {1000,
	title = {Mining Workspace Updates in CVS},
	booktitle = {Fourth International Workshop on Mining Software Repositories (MSR{\textquoteright}07:ICSE Workshops 2007)},
	year = {2007},
	pages = {11 - 11},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Minneapolis, MN, USA},
	abstract = {The version control archive CVS records not only all changes in a project but also activity data such as when developers create or update their workspaces. Furthermore, CVS records when it has to integrate changes because of parallel development. In this paper, we analyze the CVS activity data of four large open-source projects GCC, JBOSS, JEDIT, and PYTHON to investigate parallel development: What is the degree of parallel development? How frequently do conflicts occur during updates and how are they resolved? How do we identify changes that contain integrations?},
	keywords = {change management, cvs, developers, gcc, jboss, jedit, python, workspaces},
	isbn = {0-7695-2950-X},
	doi = {10.1109/MSR.2007.22},
	attachments = {https://flosshub.org/sites/flosshub.org/files/28300011.pdf},
	author = {Zimmermann, Thomas}
}
@article {flosswp298,
	title = {An Empirical Study on Implementing FLOSS in Schools},
	journal = {Social Informatics: An Information Society for All? In Remembrance of Rob Kling, the proceedings of the 7th {\textquoteright}Human Choice and Computers{\textquoteright} conference},
	year = {2006},
	publisher = {Springer Science and Business Media},
	abstract = {This empirical paper shows how free/libre open source software (FLOSS) contributes to mutual and collaborative learning in an educational environment. Unlike proprietary software, FLOSS allows extensive customisation of software and supports the needs of local users better. In this paper, we observes how implementing FLOSS in an Italian high school challenges the conventional relationship between end users themselves (e.g. teachers and students) and that between users and developers. The findings will shed some light on the social aspects of FLOSS-based computerization - including the role of FLOSS in social and organizational change in educational environments and the ways that the social organization of FLOSS are influenced by social forces and social practices.},
	attachments = {https://flosshub.org/sites/flosshub.org/files/LinZini_HCC7.pdf},
	author = {Yu-wei Lin and Enrico Zini}
}
@conference {689,
	title = {Evolution of Open Source Communities},
	booktitle = {OSS2006: Open Source Systems (IFIP 2.13)},
	series = {IFIP International Federation for Information Processing},
	year = {2006},
	note = {"we took snapshots of its membership at regular intervals"
"we chose a one year period"
"we retrieve the list of core developers ordered by their number of inbound messages, as noted above."},
	pages = {21 - 32},
	publisher = {Springer},
	organization = {Springer},
	abstract = {The goal of this paper is to document the evolution of a portfolio of related open source communities over time. As a case study, we explore the subprojects of the Apache project, one of the largest and most visible open source projects. We extract the community structure from the mailing list data, and study how the subcommunities evolve, and are interrelated over time. Our analysis leads us to propose the following hypotheses about the growth of open source communities: (1) communities add new developers by a process of preferential attachment; (2) links between existing communities are also subject to preferential attachment; (3) developers will migrate between communities together with other collaborators; and (4) information flow follows project dependencies. In particular, we are concerned with the underlying factors that motivate the migration between communities, such as information flow, co-worker ties, and project dependencies.
},
	keywords = {apache, COMMUNITY, core, developers, email, email archives, mailing list, membership},
	doi = {http://dx.doi.org/10.1007/0-387-34226-5_3},
	attachments = {https://flosshub.org/sites/flosshub.org/files/Evolution\%20of\%20Open\%20Source\%20Communities.pdf},
	author = {Weiss, Michael and Moroiu, Gabriella and Zhao, Ping}
}
@conference {693,
	title = {Impact of Social Ties on Open Source Project Team Formation},
	booktitle = {OSS2006: Open Source Systems (IFIP 2.13)},
	series = {IFIP International Federation for Information Processing },
	volume = {203/2006},
	year = {2006},
	note = {"we randomly selected 1030 new projects that were registered between X and X in 2005. A web crawler downloaded the HTML files containing project summary data and developer information on the date of registration."},
	month = {2006///},
	pages = {307 - 317},
	publisher = {Springer},
	organization = {Springer},
	abstract = {In this paper, we empirically examined the role of social ties in OSSD team formation and developer joining behavior. We find that the existence and the amount of prior social relations in the network do increase the probability of an OSS project to attract more developers. Interestingly, for projects without preexisting social ties, developers tend to join the project initiated by people with less OSSD experience. This research fills a gap in the open source literature by conducting an empirical investigation of the role of social relations on project team formation behavior. Furthermore, the adoption of social network analysis, which has received little attention in the OSS literature, can yield some interesting results on the interactions among OSS developers.
},
	keywords = {developers, metadata, social network analysis, sourceforge},
	issn = {978-0-387-34225-2},
	doi = {http://dx.doi.org/10.1007/0-387-34226-5_31},
	attachments = {https://flosshub.org/sites/flosshub.org/files/Impact\%20of\%20Social\%20Ties\%20on\%20Open\%20Source\%20Project.pdf},
	author = {Hahn, Jungpil and Moon, Jae and Zhang, Chen}
}
@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 {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 {701,
	title = {Open Source Software Development (OSSD) Based On Software Engineering},
	booktitle = {OSS2006: Open Source Systems (IFIP 2.13)},
	series = {IFIP International Federation for Information Processing },
	volume = {203/2006},
	year = {2006},
	month = {2006///},
	pages = {345 - 346},
	publisher = {Springer},
	organization = {Springer},
	abstract = {With the advent of Open Source Software (OSS) at the end of last century, many proponents believe that OSS is a new software development process and some even advocate OSS as a revolution for software engineering. The Cathedral and the Bazaar is a typical metaphor of the software development methodologies for the Closed Source Software (CSS) and the OSS. By comparing the phased (namely, requirement analysis, document design and system design, coding, testing and maintenance) software development methodology proposed by Software Engineering (SE), and by studying the management tools provided by SourceForge.net, we believe OSS development method not only follows the phased software development process, but also in return enriches the theory of SE.
},
	issn = {978-0-387-34225-2},
	doi = {http://dx.doi.org/10.1007/0-387-34226-5_39},
	attachments = {https://flosshub.org/sites/flosshub.org/files/Open\%20Source\%20Software\%20Development\%20\%28OSSD\%29.pdf},
	author = {Zhu, Dengya and Potdar, Vidyasagar and Chang, Elizabeth}
}
@proceedings {1517,
	title = {Digesting Virtual {\textquotedblleft}Geek{\textquotedblright} Culture: The Summarization of Technical Internet Relay Chats},
	year = {2005},
	month = {06/2005},
	pages = {298-305},
	address = {Ann Arbor, MI, USA},
	abstract = {This paper describes a summarization system for technical chats and emails on the Linux kernel. To reflect the complexity and sophistication of the discussions, they are clustered according to subtopic structure on the sub-message level, and immediate responding pairs are identified through machine learning methods. A resulting summary consists of one or more mini-summaries, each on a subtopic from the discussion.},
	keywords = {computational linguistics, irc, linux, summarizing},
	url = {http://acl.ldc.upenn.edu/P/P05/P05-1037.pdf},
	attachments = {https://flosshub.org/sites/flosshub.org/files/P05-1037.pdf},
	author = {Liang Zhou and Edouard Hovy}
}
@article {flosswp241,
	title = {New approaches to intellectual property : from open software to knowledge based industrial activities},
	year = {2005},
	month = {October},
	abstract = {We analyze the question of intellectual property in computer software, showing that both copyright and patents do not fit to the specificities and needs of this industry. The alternative model of Open Source Software, based on a very new juridical concept called GPL "General Public License", tends to take a growing importance. We explain its main characteristics, which consist to impose to the producers to disclose the source-code of the concerned programs and of any further improvement if they re-distribute/resell it. We show that by doing that it introduces a totally different approach of intellectual property within industrial strategies, based on a weaker intellectual protection. We discuss the consequences of such a movement in intistitutional and public policy terms and we enlarge the approach to understand its exemplariness, in the context of a knowledge based economy, for a growing number of industrial activities.},
	attachments = {https://flosshub.org/sites/flosshub.org/files/jullienzimmermann.pdf},
	author = {Nicolas Jullien and Jean-Beno\^{\i}t Zimmermann}
}
@conference {793,
	title = {Open Source and IMS Learning Design: Building the Infrastructure for eLearning},
	booktitle = {OSS2005: Open Source Systems },
	year = {2005},
	pages = {329-333},
	abstract = {The development of open, flexible eLearning specifications has significant implications for and interactions with the FOSS movement. A short overview of eLearning specifications is provided, focusing on the difference between SCORM and Learning Design (LD). The significance of LD for FOSS is examined, and common values identified. The particular contribution made by FOSS to LD infrastructure is discussed, and the importance of reference applications described. An overview is given of the FOSS applications available, divided into design time and run time, with particular reference to LD editors and the CopperCore Learning Design engine.},
	keywords = {eLearning, eLearning specification, FOSS, infrastructure, Learning Design},
	url = {http://pascal.case.unibz.it/handle/2038/1264},
	author = {Griffiths, David and Blat, Josep and Elferink, Ray and Zondergeld, Sara}
}
@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}
}
@proceedings {1201,
	title = {Exploiting the Collaboration between Open Source Developers and Research},
	year = {2004},
	pages = {97-99},
	abstract = {In this paper it is argued that open source developers and research projects carrying out user requirement analysis should collaborate at a closer level. In particular, we discuss how developers could take advantage of the knowledge generated by COSPA, a research project aimed at studying and supporting the introduction of open source software in the Public Administration. COSPA focuses on office automation and desktop system software and it could thus provide developers with user requirements from one of the main "corporate" users of software. To this aim, the project has established an "observer" status, by means of which interested parties may access COSPA{\textquoteright}s results, thereby fostering collaboration and increasing dissemination of knowledge.},
	attachments = {https://flosshub.org/sites/flosshub.org/files/succi98-100.pdf},
	author = {Succi, G. and Zuliani, P.}
}
@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}
}
@article {flosswp76,
	title = { Gift economies in the development of open source software: Anthropological reflections},
	journal = {RP Special Issue},
	year = {2003},
	month = {February},
	abstract = {Building on Eric Raymond?s work this article discusses the motivation and rewards that lead some software engineers to participate in the open source movement. It is suggested that software engineers in the open source movement may have sub-groupings which parallel kinship groups such as lineages. Within such groups gift giving is not necessarily or directly reciprocated, instead members work according to the ?axiom of kinship amity? ? direct economic calculation is not appropriate within the group. What Bourdieu calls ?symbolic capital? can be used to understand how people work in order to enhance the reputation (of themselves and their group).},
	attachments = {https://flosshub.org/sites/flosshub.org/files/rp-zeitlyn.pdf},
	author = {David Zeitlyn}
}
@article {69,
	title = {The identity crisis within the IS discipline: Defining and communicating the discipline{\textquoteright}s core properties},
	journal = {MIS Quarterly},
	volume = {27},
	number = {2},
	year = {2003},
	pages = {183{\textendash}194},
	attachments = {https://flosshub.org/sites/flosshub.org/files/westdedrick.pdf},
	author = {Izak Benbasat and Robert W. Zmud}
}
@proceedings {1179,
	title = {Toward an Empirical Assessment of the Benefits of Open Source Software},
	year = {2003},
	pages = {117-120},
	attachments = {https://flosshub.org/sites/flosshub.org/files/117-120.pdf},
	author = {Russo, Barbara and Zuliani, P. and Succi, G.}
}
@article {flosswp33,
	title = {Peripheral Members in Online Communities},
	year = {2001},
	month = {Unspecified},
	abstract = {Organizations are exploring the role communities play in knowledge management and online communities are attracting more and more attentions. One difference between online communities and conventional communities lies in the large number of peripheral members in online communities, which is the focus of the study. The study empirically verifies the important role peripheral members play in online communities. It also suggests that in addition to benefiting from online communities, peripheral members also contribute to online communities.},
	attachments = {https://flosshub.org/sites/flosshub.org/files/zhang.pdf},
	author = {Wei Zhang}
}
