@proceedings {1901,
	title = {Adoption of Academic Tools in Open Source Communities: The Debian Case Study},
	volume = {496},
	year = {2017},
	month = {05/2017},
	pages = {139-150},
	publisher = {Springer},
	abstract = {Component repositories play a key role in the open software ecosystem. Managing the evolution of these repositories is a challenging task, and maintainers are confronted with a number of complex issues that need automatic tools to be adressed properly.

In this paper, we present an overview of 10 years of research in this field and the process leading to the adoption of our tools in a FOSS community. We focus on the Debian distribution and in particular we look at the issues arising during the distribution lifecycle: ensuring buildability of source packages, detecting packages that cannot be installed and bootstrapping the distribution on a new architecture. We present three tools, distcheck, buildcheck and botch, that we believe of general interest for other open source component repositories.

The lesson we have learned during this journey may provide useful guidance for researchers willing to see their tools broadly adopted by the community.},
	keywords = {components, debian, distribution},
	doi = {10.1007/978-3-319-57735-7_14},
	url = {https://link.springer.com/chapter/10.1007/978-3-319-57735-7_14},
	author = {Abate, Pietro and Di Cosmo, Roberto}
}
@proceedings {1902,
	title = {Assessing Code Authorship: The Case of the Linux Kernel},
	volume = {496},
	year = {2017},
	month = {05/2017},
	pages = {151-163},
	publisher = {Springer},
	abstract = {Code authorship is a key information in large-scale open-source systems. Among others, it allows maintainers to assess division of work and identify key collaborators. Interestingly, open-source communities lack guidelines on how to manage authorship. This could be mitigated by setting to build an empirical body of knowledge on how authorship-related measures evolve in successful open-source communities. Towards that direction, we perform a case study on the Linux kernel. Our results show that: (a) only a small portion of developers (26\%) makes significant contributions to the code base; (b) the distribution of the number of files per author is highly skewed{\textemdash}a small group of top-authors (3\%) is responsible for hundreds of files, while most authors (75\%) are responsible for at most 11 files; (c) most authors (62\%) have a specialist profile; (d) authors with a high number of co-authorship connections tend to collaborate with others with less connections.},
	keywords = {code authorship, developer network, linux kernel},
	doi = {10.1007/978-3-319-57735-7_15},
	url = {https://link.springer.com/chapter/10.1007/978-3-319-57735-7_15},
	author = {Guilherme Avelino and Passos, Leonardo and Andre Hora and Marco Tulio Valente}
}
@proceedings {1875,
	title = {Considering the use of walled gardens for FLOSS project communication},
	year = {2017},
	month = {05/2017},
	abstract = {At its core, free, libre, and open source software (FLOSS) is defined by its adherence to a set of licenses that give various freedoms to the users of the software, for example the ability to use the software, to read or modify its source code, and to distribute the software to others. In addition, many FLOSS projects and developers also champion other values related to "freedom" and "openness", such as transparency, for example in communication and decision-making, or community-orientedness, for example in broadening access, collaboration, and participation. This paper explores how one increasingly common software development practice - communicating inside non-archived, third-party "walled gardens" - puts these FLOSS values into conflict. If communities choose to use non-archived walled gardens for communication, they may be prioritizing one type of openness (broad participation) over another (transparency). We use 18 FLOSS projects as a sample to describe how walled gardens are currently being used for intra-project communication, as well as to determine whether or not these projects provide archives of these communications. Findings will be useful to the FLOSS community as a whole as it seeks to under- stand the evolution and impact of its communication choices.},
	keywords = {apache, chat, communication, email, free software, irc, mailing list, open source, Slack, Stack Overflow, teams, Wordpress},
	doi = {10.1007/978-3-319-57735-7_1},
	url = {https://link.springer.com/content/pdf/10.1007\%2F978-3-319-57735-7_1.pdf},
	attachments = {https://flosshub.org/sites/flosshub.org/files/preprint_0.pdf},
	author = {Squire, Megan}
}
@proceedings {1890,
	title = {Designing for Participation: Three Models for Developer Involvement in Hybrid OSS Projects},
	volume = {496},
	year = {2017},
	month = {05/2017},
	pages = {23-33},
	publisher = {Springer},
	abstract = {This paper reports governance practices of three profit oriented companies that develop OSS software with the help of their respective open development communities. We explore how the companies allow development contributions from external stakeholders, and what knowledge they let out of their internal software development activities. The results lay ground for further research on how to organize openness of the software development process in hybrid setups where the needs of different stakeholders are partly competing - yet complementary.},
	keywords = {Community Management, Hybrid open source, open source},
	doi = {10.1007/978-3-319-57735-7_3},
	url = {https://link.springer.com/chapter/10.1007/978-3-319-57735-7_3},
	author = {M{\"a}enp{\"a}{\"a}, Hanna and Kilamo, Terhi and Mikkonen, Tommi and M{\"a}nnist{\"o}, Tomi}
}
@proceedings {1913,
	title = {An Empirical Analysis of Build Failures in the Continuous Integration Workflows of Java-Based Open-Source Software},
	year = {2017},
	note = {"empirical study of CI build
failures in 14 Java-based OSS projects. We extract and analyze
data from publicly available GitHub repositories and Travis-CI
build logs"},
	month = {05/2017},
	pages = {345-355},
	abstract = {{\textemdash}Continuous Integration (CI) has become a common
practice in both industrial and open-source software development.
While CI has evidently improved aspects of the software
development process, errors during CI builds pose a threat to
development efficiency. As an increasing amount of time goes
into fixing such errors, failing builds can significantly impair the
development process and become very costly. We perform an indepth
analysis of build failures in CI environments. Our approach
links repository commits to data of corresponding CI builds.
Using data from 14 open-source Java projects, we first identify
14 common error categories. Besides test failures, which are by
far the most common error category (up to >80\% per project),
we also identify noisy build data, e.g., induced by transient Git
interaction errors, or general infrastructure flakiness. Second,
we analyze which factors impact the build results, taking into
account general process and specific CI metrics. Our results
indicate that process metrics have a significant impact on the
build outcome in 8 of the 14 projects on average, but the strongest
influencing factor across all projects is overall stability in the
recent build history. For 10 projects, more than 50\% (up to 80\%)
of all failed builds follow a previous build failure. Moreover, the
fail ratio of the last k=10 builds has a significant impact on build
results for all projects in our dataset.},
	keywords = {build errors, continuous integration, correlation analysis, msr},
	author = {Thomas Rausch and Waldemar Hummer and Philipp Leitner and Stefan Schulte}
}
@article {1872,
	title = {Empirical analysis of search based algorithms to identify change prone classes of open source software},
	journal = {Computer Languages, Systems \& Structures},
	volume = {47},
	year = {2017},
	month = {01/2017},
	pages = {211 - 231},
	abstract = {There are numerous reasons leading to change in software such as changing requirements, changing technology, increasing customer demands, fixing of defects etc. Thus, identifying and analyzing the change-prone classes of the software during software evolution is gaining wide importance in the field of software engineering. This would help software developers to judiciously allocate the resources used for testing and maintenance. Software metrics can be used for constructing various classification models which can be used for timely identification of change prone classes. Search based algorithms which form a subset of machine learning algorithms can be utilized for constructing prediction models to identify change prone classes of software. Search based algorithms use a fitness function to find the best optimal solution among all the possible solutions. In this work, we analyze the effectiveness of hybridized search based algorithms for change prediction. In other words, the aim of this work is to find whether search based algorithms are capable for accurate model construction to predict change prone classes. We have also constructed models using machine learning techniques and compared the performance of these models with the models constructed using Search Based Algorithms. The validation is carried out on two open source Apache projects, Rave and Commons Math. The results prove the effectiveness of hybridized search based algorithms in predicting change prone classes of software. Thus, they can be utilized by the software developers to produce an efficient and better developed software.},
	keywords = {Change proneness; Metrics; Object oriented paradigm; Search based algorithms; Software quality; Empirical validation},
	issn = {14778424},
	doi = {10.1016/j.cl.2016.10.001},
	author = {Bansal, Ankita}
}
@proceedings {1895,
	title = {How are Developers Treating License Inconsistency Issues? A Case Study on License Inconsistency Evolution in FOSS Projects},
	volume = {496},
	year = {2017},
	month = {05/2017},
	pages = {69-79},
	publisher = {Springer},
	abstract = {A license inconsistency is the presence of two or more source files that evolved from the same original file containing different licenses. In our previous study, we have shown that license inconsistencies do exist in open source projects and may lead to potential license violation problems. In this study, we try to find out whether the issues of license inconsistencies are properly solved by analyzing two versions of a FOSS distribution{\textemdash}Debian{\textemdash}and investigate the evolution patterns of license inconsistencies. Findings are: license inconsistencies occur mostly because the original copyright owner updated the license while the reusers were still using the old version of the source files with the old license; most license inconsistencies would disappear when the reusers synchronize their project from the upstream, while some would exist permanently if reusers decide not to synchronize anymore. Legally suspicious cases have not been found yet in those Debian distributions.},
	keywords = {Code clone, debian, License inconsistency, licenses, Software license},
	doi = {10.1007/978-3-319-57735-7_8},
	url = {https://link.springer.com/chapter/10.1007/978-3-319-57735-7_8},
	author = {Y. Wu and Manabe, Yuki and Daniel M. Germ{\'a}n and Inoue, K.}
}
@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}
}
@proceedings {1905,
	title = {Longitudinal Analysis of the Run-up to a Decision to Break-up (Fork) in a Community},
	volume = {496},
	year = {2017},
	month = {05/2017},
	pages = {204-217},
	publisher = {Springer},
	abstract = {In this paper, we use a developer-oriented statistical approach to understand what causes people in complex software development networks to decide to fork (break away), and what changes a community goes through in the run-up to a decision to break-up. Developing complex software systems is complex. Software developers interact. They may have the same or different goals, communication styles, or values. Interactions can be healthy or troubled. Troubled interactions cause troubled communities, that face failure. Some of these failures manifest themselves as a community split (known as forking). These failures affects many people; developers and users. Can we save troubled projects? We statistically model the longitudinal socio-grams of software developers and present early indicators and warning signs that can be used to predict an imminent break-up decision.

},
	keywords = {community of software developers, forks, longitudinal study},
	doi = {10.1007/978-3-319-57735-7_19},
	url = {https://link.springer.com/chapter/10.1007/978-3-319-57735-7_19},
	author = {Amirhosein {\textquotedblleft}Emerson{\textquotedblright} Azarbakht and Jensen, Carlos}
}
@proceedings {1911,
	title = {Machine Learning-Based Detection of Open Source License Exceptions},
	year = {2017},
	note = {"We address these questions by first performing a large scale mining-based study... [W]e analyzed the  source code of 51,754 projects written in six different programming languages (Ruby, Javascript, Python, C, C++, and C$\#$) hosted on GitHub. },
	month = {05/2017},
	pages = {118-129},
	abstract = {From a legal perspective, software licenses govern the redistribution, reuse, and modification of software as both source and binary code. Free and Open Source Software (FOSS) licenses vary in the degree to which they are permissive or restrictive in allowing redistribution or modification under licenses different from the original one(s). In certain cases developers may modify the license by appending to it an exception to specifically allow reuse or modification under a particular condition. These exceptions are an important factor to consider for license compliance analysis since they modify the standard (and widely understood_ terms of the original license. In this work, we first perform a large-scale empirical study on the change history of over 51k FOSS systems aimed at quantitatively investigating the prevalence of known license exceptions and identifying new ones. Subsequently, we performed a study on the detection of license exceptions by relying on machine learning. We evaluated the license exception classification with four different supervised learners and sensitivity analysis. Finally we present a categorization of license exceptions and explain their implications.},
	keywords = {classifier, empirical studies, license, machine learning},
	doi = {10.1109/ICSE.2017.19},
	author = {Vendome, Christopher and Mario Linares-Vasquez and Bavota, Gabriele and Di Penta, Massimiliano and Daniel M. German and Poshyvanyk, Denys}
}
@proceedings {1914,
	title = {Practices and Perceptions of UML Use in Open Source Projects},
	year = {2017},
	month = {05/2017},
	pages = {203-212},
	abstract = {Context: Open Source is getting more and more
collaborative with industry. At the same time, modeling is today
playing a crucial role in development of, e.g., safety critical
software. Goal: However, there is a lack of research about the
use of modeling in Open Source. Our goal is to shed some
light into the motivation and benefits of the use of modeling
and its use within project teams. Method: In this study, we
perform a survey among Open Source developers. We focus on
projects that use the Unified Modeling Language (UML) as a
representative for software modeling. Results: We received 485
answers of contributors of 458 different Open Source projects.
Conclusion: Collaboration seems to be the most important
motivation for using UML. It benefits new contributors and
contributors who do not create models. Teams use UML during
communication and planning of joint implementation efforts.},
	keywords = {architecture documentation, communication, effectiveness of UML, github, MOTIVATION, UML},
	author = {Truong Ho-Quang and Hebig, Regina and Gregorio Robles and Chaudron, Michel R. V. and Miguel Angel Fernandez}
}
@article {1920,
	title = {Process Aspects and Social Dynamics of Contemporary Code Review: Insights from Open Source Development and Industrial Practice at Microsoft},
	journal = {IEEE Transactions on Software Engineering},
	volume = {43},
	year = {2017},
	note = {" We sent the survey
to code review participants from 36 popular OSS projects
and received 287 responses"},
	month = {1/2017},
	pages = {56 - 75},
	abstract = {Many open source and commercial developers practice contemporary code review, a lightweight, informal, tool-based code
review process. To better understand this process and its benefits, we gathered information about code review practices via surveys of
open source software developers and developers from Microsoft. The results of our analysis suggest that developers spend
approximately 10-15 percent of their time in code reviews, with the amount of effort increasing with experience. Developers consider
code review important, stating that in addition to finding defects, code reviews offer other benefits, including knowledge sharing,
community building, and maintaining code quality. The quality of the code submitted for review helps reviewers form impressions about
their teammates, which can influence future collaborations. We found a large amount of similarity between the Microsoft and OSS
respondents. One interesting difference is that while OSS respondents view code review as an important method of impression
formation, Microsoft respondents found knowledge dissemination to be more important. Finally, we found little difference between
distributed and co-located Microsoft teams. Our findings identify the following key areas that warrant focused research: 1) exploring the
non-technical benefits of code reviews, 2) helping developers in articulating review comments, and 3) assisting reviewers{\textquoteright} program
comprehension during code reviews.},
	keywords = {code review, commercial projects, peer impressions, Survey},
	issn = {1939-3520},
	doi = {10.1109/TSE.2016.2576451},
	url = {https://amiangshu.com/papers/CodeReview-TSE-2016.pdf},
	attachments = {https://flosshub.org/sites/flosshub.org/files/CodeReview-TSE-2016.pdf},
	author = {Bosu, Amiangshu and Carver, Jeffrey C. and Christian Bird and Orbeck, Jonathan and Chockley, Christopher}
}
@proceedings {1899,
	title = {Progression and Forecast of a Curated Web-of-Trust: A Study on the Debian Project{\textquoteright}s Cryptographic Keyring},
	volume = {496},
	year = {2017},
	month = {05/2017},
	pages = {117-127},
	publisher = {Springer},
	abstract = {The Debian project is one of the largest free software undertakings worldwide. It is geographically distributed, and participation in the project is done on a voluntary basis, without a single formal employee or directly funded person. As we will explain, due to the nature of the project, its authentication needs are very strict{\textemdash}User/password schemes are way surpassed, and centralized trust management schemes such as PKI are not compatible with its distributed and flat organization; fully decentralized schemes such as the PGP Web of Trust are insuficient by themselves. The Debian project has solved this need by using what we termed a {\textquotedblleft}curated Web of Trust{\textquotedblright}.

We will explain some lessons learned from a massive key migration process that was triggered in 2014. We will present the social insight we have found from examining the relationships expressed as signatures in this curated Web of Trust, some recommendations on personal key-signing policies, and a statistical study and forecast on aging, refreshment and survival of project participants stemming from an analysis on their key-handling.},
	keywords = {cryptography, curated Web of Trust, debian, Keyring, trust management},
	doi = {10.1007/978-3-319-57735-7_12},
	url = {https://link.springer.com/chapter/10.1007/978-3-319-57735-7_12},
	author = {Gunnar Wolf and V{\'\i}ctor Gonz{\'a}lez Quiroga}
}
@conference {Izquierdo-Cortazar:2017:UMT:3084226.3084247,
	title = {Using Metrics to Track Code Review Performance},
	booktitle = {Proceedings of the 21st International Conference on Evaluation and Assessment in Software Engineering},
	series = {EASE{\textquoteright}17},
	year = {2017},
	pages = {214{\textendash}223},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {During 2015, some members of the Xen Project Advisory Board became worried about the performance of their code review process. The Xen Project is a free, open source software project developing one of the most popular virtualization platforms in the industry. They use a pre-commit peer review process similar to that in the Linux kernel, based on email messages. They had observed a large increase over time in the number of messages related to code review, and were worried about how this could be a signal of problems with their code review process.

To address these concerns, we designed and conducted, with their continuous feedback, a detailed analysis focused on finding these problems, if any. During the study, we dealt with the methodological problems of Linux-like code review, and with the deeper issue of finding metrics that could uncover the problems they were worried about. For having a benchmark, we run the same analysis on a similar project, which uses very similar code review practices: the Linux Netdev (Netdev) project. As a result, we learned how in fact the Xen Project had some problems, but at the moment of the analysis those were already under control. We found as well how different the Xen and Netdev projects were behaving with respect to code review performance, despite being so similar from many points of view.

In this paper we show the results of both analyses, and propose a comprehensive methodology, fully automated, to study Linux-style code review. We discuss also the problems of getting significant metrics to track improvements or detect problems in this kind of code review.},
	keywords = {code review, data mining, Software development analytics},
	isbn = {978-1-4503-4804-1},
	doi = {10.1145/3084226.3084247},
	url = {http://doi.acm.org/10.1145/3084226.3084247},
	author = {Izquierdo-Cortazar, Daniel and Sekitoleko, Nelson and Jesus M. Gonzalez-Barahona and Kurth, Lars}
}
@article {Krishnamurthy:2016:PDP:2869770.2820618,
	title = {Peripheral Developer Participation in Open Source Projects: An Empirical Analysis},
	journal = {ACM Trans. Manage. Inf. Syst.},
	volume = {6},
	number = {4},
	year = {2016},
	pages = {14:1{\textendash}14:31},
	publisher = {ACM},
	address = {New York, NY, USA},
	abstract = {The success of the Open Source model of software development depends on the voluntary participation of external developers (the peripheral developers), a group that can have distinct motivations from that of project founders (the core developers). In this study, we examine peripheral developer participation by empirically examining approximately 2,600 open source projects. In particular, we hypothesize that peripheral developer participation is higher when the potential for building reputation by gaining recognition from project stakeholders is higher. We consider recognition by internal stakeholders (such as core developers) and external stakeholders (such as end-users and peers). We find a positive association between peripheral developer participation and the potential of stakeholder recognition after controlling for bug reports, feature requests, and other key factors. Our findings provide important insights for OSS founders and corporate managers for open sourcing or OSS adoption decisions.
},
	keywords = {Code ownership, open source software, project management, software metrics},
	issn = {2158-656X},
	doi = {10.1145/2820618},
	url = {http://doi.acm.org/10.1145/2820618},
	author = {Krishnamurthy, Rajiv and Jacob, Varghese and Radhakrishnan, Suresh and Kutsal Dogan}
}
@article {1864,
	title = {Roles and politeness behavior in community-based free/libre open source software development},
	journal = {Information \& Management},
	year = {2016},
	month = {11/2016},
	abstract = {Community-based Free/Libre Open Source Software (FLOSS) development relies on contributions from both core and peripheral members. Prior research on core{\textendash}periphery has focused on software coding-related behaviors. We study how core{\textendash}periphery roles are related to social-relational behavior in terms of politeness behavior. Data from two FLOSS projects suggest that both core and peripheral members use more positive politeness strategies than negative strategies. Further, core and peripheral members use different strategies to protect positive face in positive politeness, which we term respect and intimacy, respectively. Our results contribute to FLOSS research and politeness theory.

},
	keywords = {Core{\textendash}periphery structure, open source software development, Politeness behavior},
	issn = {03787206},
	doi = {10.1016/j.im.2016.11.006},
	url = {https://crowston.syr.edu/sites/crowston.syr.edu/files/Group_maintenance\%20paper\%20to\%20share.pdf},
	author = {Kangning Wei and Kevin Crowston and Eseryel, U.Yeliz and Robert Heckman}
}
@proceedings {1763,
	title = {A Dataset of High Impact Bugs: Manually-Classified Issue Reports},
	year = {2015},
	month = {05/2015},
	publisher = {IEEE},
	abstract = {The importance of supporting test and maintenance
activities in software development has been increasing, since
recent software systems have become large and complex. Although
in the field of Mining Software Repositories (MSR) there
are many promising approaches to predicting, localizing, and
triaging bugs, most of them do not consider impacts of each
bug on users and developers but rather treat all bugs with equal
weighting, excepting a few studies on high impact bugs including
security, performance, blocking, and so forth. To make MSR
techniques more actionable and effective in practice, we need
deeper understandings of high impact bugs. In this paper we
introduced our dataset of high impact bugs which was created
by manually reviewing four thousand issue reports in four open
source projects (Ambari, Camel, Derby and Wicket).},
	keywords = {ambari, camel, derby, wicket},
	url = {http://oss.sys.wakayama-u.ac.jp/publications/pman3.cgi?DOWNLOAD=141},
	attachments = {https://flosshub.org/sites/flosshub.org/files/5594a518.pdf},
	author = {Ohira, Masao and Yutaro Kashiwa and Yosuke Yamatani and Hayato Yoshiyuki and Yoshiya Maeda and Nachai Limsettho and Keisuke Fujino and Hata, Hideaki and Ihara, Akinori and Kenichi Matsumoto}
}
@inbook {1734,
	title = {Examining Usability Work and Culture in OSS},
	booktitle = {Open Source Systems: Adoption and Impact},
	series = {IFIP Advances in Information and Communication Technology},
	volume = {451},
	year = {2015},
	pages = {58-67},
	publisher = {Springer International Publishing},
	organization = {Springer International Publishing},
	abstract = {Organizational culture has been recognized as an influential factor affecting the successes and failures of usability work in organizations; however, there is a lack of research on organizational culture in open source software (OSS) development. This paper shows that there are different kinds of cultures in OSS development projects and builds propositions on the relationship between culture and usability work in OSS development projects. Partly those are derived from the literature, partly from an exploratory empirical inquiry. We speculate whether there is an ideal culture type for usability work in OSS development or whether usability work should be modified to fit the different cultures of OSS development projects.
},
	keywords = {culture, empirical study, open source software, Usability},
	isbn = {978-3-319-17836-3},
	doi = {10.1007/978-3-319-17837-0_6},
	url = {http://dx.doi.org/10.1007/978-3-319-17837-0_6},
	author = {Rajanen, Mikko and Iivari, Netta},
	editor = {Damiani, Ernesto and Frati, Fulvio and Dirk Riehle and Wasserman, Anthony I.}
}
@inbook {1741,
	title = {First Results About Motivation and Impact of License Changes in Open Source Projects},
	booktitle = {Open Source Systems: Adoption and Impact},
	series = {IFIP Advances in Information and Communication Technology},
	volume = {451},
	year = {2015},
	pages = {137-145},
	publisher = {Springer International Publishing},
	organization = {Springer International Publishing},
	abstract = {Free and open source software is characterized by the freedoms and criteria that are warranted by specific licenses. These licenses describe the rights and duties of the licensors and licensees. However, a licensing change may be necessary in the life of an open source project to meet legal developments or to allow the implementation of new business models. This paper examines the motivations and impacts of license changes in open source projects. After a state of the art on the subject, a set of case studies where projects changed their license is presented. Then a set of motivations to change licenses, the ways to legally make this change, the problems caused by this change and a set of benefits of the license change are discussed.
},
	keywords = {Business model, Contributor agreement, intellectual property, license, open source},
	isbn = {978-3-319-17836-3},
	doi = {10.1007/978-3-319-17837-0_13},
	url = {http://dx.doi.org/10.1007/978-3-319-17837-0_13},
	author = {Viseur, Robert and Gregorio Robles},
	editor = {Damiani, Ernesto and Frati, Fulvio and Dirk Riehle and Wasserman, Anthony I.}
}
@inbook {1732,
	title = {How Developers Acquire FLOSS Skills},
	booktitle = {Open Source Systems: Adoption and Impact},
	series = {IFIP Advances in Information and Communication Technology},
	volume = {451},
	year = {2015},
	pages = {23-32},
	publisher = {Springer International Publishing},
	organization = {Springer International Publishing},
	abstract = {With the increasing prominence of open collaboration as found in free/libre/open source software projects and other joint production communities, potential participants need to acquire skills. How these skills are learned has received little research attention. This article presents a large-scale survey (5,309 valid responses) in which users and developers of the beta release of a popular file download application were asked which learning styles were used to acquire technical and social skills. We find that the extent to which a person acquired the relevant skills through informal methods tends to be higher if the person is a free/libre/open source code contributor, while being a professional software developer does not have this effect. Additionally, younger participants proved more likely to make use of formal methods of learning. These insights will help individuals, commercial companies, educational institutions, governments and open collaborative projects decide how they promote learning.
},
	keywords = {competencies, Informal learning, Non-formal learning, open source, Skills, Software developer},
	isbn = {978-3-319-17836-3},
	doi = {10.1007/978-3-319-17837-0_3},
	url = {http://dx.doi.org/10.1007/978-3-319-17837-0_3},
	attachments = {https://flosshub.org/sites/flosshub.org/files/oss-2015.pdf},
	author = {Barcomb, Ann and Grottke, Michael and Stauffert, Jan-Philipp and Dirk Riehle and Jahn, Sabrina},
	editor = {Damiani, Ernesto and Frati, Fulvio and Dirk Riehle and Wasserman, Anthony I.}
}
@proceedings {1769,
	title = {Investigating Code Review Practices in Defective Files: An Empirical Study of the Qt System},
	year = {2015},
	month = {05/2015},
	publisher = {IEEE},
	abstract = {Software code review is a well-established software
quality practice. Recently, Modern Code Review (MCR) has been
widely adopted in both open source and proprietary projects.
To evaluate the impact that characteristics of MCR practices
have on software quality, this paper comparatively studies MCR
practices in defective and clean source code files. We investigate
defective files along two perspectives: 1) files that will eventually
have defects (i.e., future-defective files) and 2) files that have
historically been defective (i.e., risky files). Through an empirical
study of 11,736 reviews of changes to 24,486 files from the Qt
open source project, we find that both future-defective files and
risky files tend to be reviewed less rigorously than their clean
counterparts. We also find that the concerns addressed during
the code reviews of both defective and clean files tend to enhance
evolvability, i.e., ease future maintenance (like documentation),
rather than focus on functional issues (like incorrect program
logic). Our findings suggest that although functionality concerns
are rarely addressed during code review, the rigor of the
reviewing process that is applied to a source code file throughout
a development cycle shares a link with its defect proneness.},
	keywords = {code review, software quality},
	url = {http://sail.cs.queensu.ca/publications/pubs/msr2015-thongtanunam.pdf},
	attachments = {https://flosshub.org/sites/flosshub.org/files/msr2015-thongtanunam.pdf},
	author = {Patanamon Thongtanunam and McIntosh, Shane and Hassan, Ahmed E. and Hajimu Iida}
}
@booklet {1781,
	title = {Lessons Learned from Applying Social Network Analysis on an Industrial Free/Libre/Open Source Software Ecosystem},
	year = {2015},
	abstract = {Many software projects are no longer done in-house by a single organization. Instead, we are in a new age where software is developed by a networked community of individuals and organizations, which base their relations to each other on mutual interest. Paradoxically, recent research suggests that software development can actually be jointly-developed by rival firms. For instance, it is known that the mobile-device makers Apple and Samsung kept collaborating in open source projects while running expensive patent wars in the court. Taking a case study approach, we explore how rival firms collaborate in the open source arena by employing a multi-method approach that combines qualitative analysis of archival data (QA) with mining software repositories (MSR) and Social Network Analysis (SNA). While exploring collaborative processes within the OpenStack ecosystem, our research contributes to Software Engineering research by exploring the role of groups, sub-communities and business models within a high-networked open source ecosystem. Surprising results point out that competition for the same revenue model (i.e., operating conflicting business models) does not necessary affect collaboration within the ecosystem. Moreover, while detecting the different sub-communities of the OpenStack community, we found out that the expected social tendency of developers to work with developers from same firm (i.e., homophony) did not hold within the OpenStack ecosystem. Furthermore, while addressing a novel, complex and unexplored open source case, this research also contributes to the management literature in coopetition strategy and high-tech entrepreneurship with a rich description on how heterogeneous actors within a high-networked ecosystem (involving individuals, startups, established firms and public organizations) joint-develop a complex infrastructure for big-data in the open source arena.},
	keywords = {business models, cloud computing, homophily, open source, Open-Coopetition, openstack, social network analysis, Software ecosystems},
	url = {http://arxiv.org/abs/1507.04587},
	author = {Teixeira, Jose and Gregorio Robles and Jesus M. Gonzalez-Barahona}
}
@inbook {1731,
	title = {Scaling and Internationalizing an Agile FOSS Project: Lessons Learned},
	booktitle = {Open Source Systems: Adoption and Impact},
	series = {IFIP Advances in Information and Communication Technology},
	volume = {451},
	year = {2015},
	pages = {13-22},
	publisher = {Springer International Publishing},
	organization = {Springer International Publishing},
	abstract = {This paper describes problems that arose with the scaling and internationalization of the open source project Catrobat. The problems we faced were the lack of a centralized user management, insufficient scaling of our communication channels, and the necessity to adapt agile development techniques to remote collaboration. To solve the problems we decided to use a mix of open source tools (Git, IRC, LDAP) and commercial solutions (Jira, Confluence, GitHub) because we believe that this mix best fits our needs. Other projects can benefit from the lessons we learned during the reorganization of our knowledge base and communication tools, as infrastructure changes can be very labor-intensive and time-consuming.},
	keywords = {Agile development, communication, Distributed software development, Documentation management, Internationalization, kanban, Scaling},
	isbn = {978-3-319-17836-3},
	doi = {10.1007/978-3-319-17837-0_2},
	url = {http://dx.doi.org/10.1007/978-3-319-17837-0_2},
	author = {Fellhofer, Stephan and Harzl, Annemarie and Slany, Wolfgang},
	editor = {Damiani, Ernesto and Frati, Fulvio and Dirk Riehle and Wasserman, Anthony I.}
}
@article {1805,
	title = {Stigmergic coordination in FLOSS development teams: Integrating explicit and implicit mechanisms},
	journal = {Cognitive Systems Research},
	year = {2015},
	month = {12/2015},
	abstract = {The vast majority of literature on coordination in team-based projects has drawn on a conceptual separation between explicit (e.g. plans, feedbacks) and implicit coordination mechanisms (e.g. mental maps, shared knowledge). This analytical distinction presents some limitations in explaining how coordination is reached in organizations characterized by distributed teams, scarce face to face meetings and fuzzy and changing lines of authority, as in free/libre open source software (FLOSS) development.

Analyzing empirical illustrations from two FLOSS projects, we highlight the existence of a peculiar model, stigmergic coordination, which includes aspects of both implicit and explicit mechanisms. The work product itself (implicit) and the characteristics under which it is shared (explicit) play an under-appreciated role in helping software developers manage dependencies as they arise. We develop this argument beyond the existing literature by working with an existing coordination framework, considering the role that the codebase itself might play at each step. We also discuss the features and the practices to support stigmergic coordination in distributed teams, as well as recommendations for future research. {\textquotedblleft}Not everything that implicitly exists needs to be rendered explicit{\textquotedblright} (Sloterdijk, 2009, p. 3).},
	keywords = {Coordination mechanisms, distributed teams, FLOSS teams, Stigmergic coordination},
	issn = {13890417},
	doi = {10.1016/j.cogsys.2015.12.003},
	url = {http://www.sciencedirect.com/science/article/pii/S1389041715000339},
	attachments = {https://flosshub.org/sites/flosshub.org/files/COGSYS-RS-\%28HHS\%29-\%282015\%29-\%283\%29.pdf},
	author = {Bolici, Francesco and Howison, James and Kevin Crowston}
}
@booklet {1709,
	title = {Understanding and Supporting the Choice of an Appropriate Task to Start With In Open Source Software Communities },
	howpublished = {Hawaii International Conference on System Sciences 48},
	year = {2015},
	pages = {5299-5308},
	publisher = {IEEE},
	abstract = {Open Source Software (OSS) projects leverage the
contribution of outsiders. In fact, the sustainability of
many projects relies on retaining some of these
newcomers. Usually these communities do not
coordinate the work of the newcomers, who go to the
issue trackers and self-select a task to start with. We
found that {\textquotedblleft}finding a way to start{\textquotedblright} was reported as an
important issue by practitioners. To further investigate
this specific barrier, we conducted a qualitative
analysis with data obtained from semi-structured
interviews with 36 subjects from 14 different projects,
including newcomers and experienced members. We
used procedures of Grounded Theory {\textendash} open and axial
coding {\textendash} to analyze the data. We found that newcomers
are not confident enough to choose their initial task
and they need information about the tasks or direction
from the community to support choosing a task more
suitable for them. We also present a set of strategies
identified in the literature, interviews, and state-of-the practice
that can provide newcomers with such
information, enabling them to be more confident when
choosing their first tasks and collaborate with the
community. },
	keywords = {coordination, joining process, new developer, newcomers, onboarding, open source software, task selection},
	attachments = {https://flosshub.org/sites/flosshub.org/files/HICSS-48_present.pdf},
	author = {Steinmacher, Igor and Conte, Tayana and Gerosa, MarcoAur{\'e}lio}
}
@proceedings {1752,
	title = {Why Power Laws? An Explanation from Fine-Grained Code Changes},
	year = {2015},
	note = {"The data used in this section come from four open source Java projects. We used CVSANALY to collect data from their Git repositories."},
	abstract = {Throughout the years, empirical studies have found
power law distributions in various measures across many software
systems. However, surprisingly little is known about how
they are produced. What causes these power law distributions?
We offer an explanation from the perspective of fine-grained
code changes. A model based on preferential attachment and selforganized
criticality is proposed to simulate software evolution.
The experiment shows that the simulation is able to render power
law distributions out of fine-grained code changes, suggesting
preferential attachment and self-organized criticality are the
underlying mechanism causing the power law distributions in
software systems.},
	keywords = {Apache Maven, cvsanaly, eclipse, git, Google Guice, java, jedit, open source},
	url = {https://users.soe.ucsc.edu/~linzhp/msr2015.pdf},
	attachments = {https://flosshub.org/sites/flosshub.org/files/msr2015.pdf},
	author = {Zhongpeng Lin and Jim Whitehead}
}
@proceedings {1573,
	title = {"A bit of code": How the Stack Overflow Community Creates Quality Postings},
	year = {2014},
	month = {01/2014},
	pages = {1425-1434},
	publisher = {IEEE Computer Society},
	abstract = {The Stack Overflow web site is an online community where programmers can ask and answer one another{\textquoteright}s questions, earning points and badges. The site offers guidance in the form of a Frequently Asked Questions (FAQ), beginning with "What kind of questions can I ask here?" The answer explains that "the best Stack Overflow questions have a bit of source code in them". This paper explores the role of source code and non-source code text on Stack Overflow in both questions and answers. The primary contribution of this paper is to provide a more detailed understanding of whether the presence of source code (and how much) actually will produce the "best" Stack Overflow questions or answers. A second contribution of this paper is to determine how the non-code portions of the text might also contribute the "best" Stack Overflow postings.  },
	keywords = {COLLABORATION, collaborative development, data mining, developer network, knowledge collaboration, open content, text mining},
	doi = {http://dx.doi.org/10.1109/HICSS.2014.185},
	attachments = {https://flosshub.org/sites/flosshub.org/files/hicssSMFinalWatermark.pdf},
	author = {Squire, Megan and Funkhouser, Christian}
}
@conference {ValdiviaGarcia:2014:CPB:2597073.2597099,
	title = {Characterizing and Predicting Blocking Bugs in Open Source Projects},
	booktitle = {Proceedings of the 11th Working Conference on Mining Software Repositories},
	series = {MSR 2014},
	year = {2014},
	pages = {72{\textendash}81},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {As software becomes increasingly important, its quality becomes an increasingly important issue. Therefore, prior work focused on software quality and proposed many prediction models to identify the location of software bugs, to estimate their fixing-time, etc. However, one special type of severe bugs is blocking bugs. Blocking bugs are software bugs that prevent other bugs from being fixed. These blocking bugs may increase maintenance costs, reduce overall quality and delay the release of the software systems.

In this paper, we study blocking-bugs in six open source projects and propose a model to predict them. Our goal is to help developers identify these blocking bugs early on. We collect the bug reports from the bug tracking systems of the projects, then we obtain 14 different factors related to, for example, the textual description of the bug, the location the bug is found in and the people involved with the bug. Based on these factors we build decision trees for each project to predict whether a bug will be a blocking bug or not. Then, we analyze these decision trees in order to determine which factors best indicate these blocking bugs. Our results show that our prediction models achieve F-measures of 15-42\%, which is a two- to four-fold improvement over the baseline random predictors. We also find that the most important factors in determining blocking bugs are the comment text, comment size, the number of developers in the CC list of the bug report and the reporter{\textquoteright}s experience. Our analysis shows that our models reduce the median time to identify a blocking bug by 3-18 days.},
	keywords = {Code Metrics, Post-release Defects, Process Metrics},
	isbn = {978-1-4503-2863-0},
	doi = {10.1145/2597073.2597099},
	url = {http://doi.acm.org/10.1145/2597073.2597099},
	attachments = {https://flosshub.org/sites/flosshub.org/files/garcia.pdf},
	author = {Valdivia Garcia, Harold and Shihab, Emad}
}
@conference {Krutz:2014:CCO:2597073.2597127,
	title = {A Code Clone Oracle},
	booktitle = {Proceedings of the 11th Working Conference on Mining Software Repositories},
	series = {MSR 2014},
	year = {2014},
	pages = {388{\textendash}391},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {Code clones are functionally equivalent code segments. Detecting code clones is important for determining bugs, fixes and software reuse. Code clone detection is also essential for developing fast and precise code search algorithms. How- ever, the challenge of such research is to evaluate that the clones detected are indeed functionally equivalent, consider- ing the majority of clones are not textual or even syntactically identical. The goal of this work is to generate a set of method level code clones with a high confidence to help to evaluate future code clone detection and code search tools to evaluate their techniques. We selected three open source programs, Apache, Python and PostgreSQL, and randomly sampled a total of 1536 function pairs. To confirm whether or not these function pairs indicate a clone and what types of clones they belong to, we recruited three experts who have experience in code clone research and four students who have experience in programming for manual inspection. For confidence of the data, the experts consulted multiple code clone detection tools to make the consensus. To assist manual inspection, we built a tool to automatically load function pairs of interest and record the manual inspection results. We found that none of the 66 pairs are textual identical type- 1 clones, and 9 pairs are type-4 clones. Our data is available at: http://phd.gccis.rit.edu/weile/data/cloneoracle/.
},
	keywords = {clone, Clone Oracle, Code Clone Detection, msr data showcase, software engineering},
	isbn = {978-1-4503-2863-0},
	doi = {10.1145/2597073.2597127},
	url = {http://doi.acm.org/10.1145/2597073.2597127},
	attachments = {https://flosshub.org/sites/flosshub.org/files/clone_oracle.pdf},
	author = {Krutz, Daniel E. and Le, Wei}
}
@conference {Aggarwal:2014:CPD:2597073.2597120,
	title = {Co-evolution of Project Documentation and Popularity Within Github},
	booktitle = {Proceedings of the 11th Working Conference on Mining Software Repositories},
	series = {MSR 2014},
	year = {2014},
	pages = {360{\textendash}363},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {Github is a very popular collaborative software-development platform that provides typical source-code management and issue tracking features augmented by strong social-networking features such as following developers and watching projects. These features help "spread the word" about individuals and projects, building the reputation of the former and increasing the popularity of the latter. In this paper, we investigate the relation between project popularity and regular, consistent documentation updates. We found strong indicators that consistently popular projects exhibited consistent documentation effort and that this effort tended to attract more documentation collaborators. We also found that frameworks required more documentation effort than libraries to achieve similar adoption success, especially in the initial phase.
},
	keywords = {Cross Correlation, Documentation Change, mining challenge, msr challenge, popularity},
	isbn = {978-1-4503-2863-0},
	doi = {10.1145/2597073.2597120},
	url = {http://doi.acm.org/10.1145/2597073.2597120},
	author = {Aggarwal, Karan and Hindle, Abram and Stroulia, Eleni}
}
@conference {Tymchuk:2014:COP:2597073.2597093,
	title = {Collaboration in Open-source Projects: Myth or Reality?},
	booktitle = {Proceedings of the 11th Working Conference on Mining Software Repositories},
	series = {MSR 2014},
	year = {2014},
	pages = {304{\textendash}307},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {One of the fundamental principles of open-source projects is that they foster collaboration among developers, disregarding their geographical location or personal background. When it comes to software repositories collaboration is a rather ephemeral phenomenon which lacks a clear definition, and it must therefore be mined and modeled. This throws up the question whether what is mined actually maps to reality.

In this paper we investigate collaboration by modeling it using a number of diverse approaches that we then compare to a ground truth obtained by surveying a substantial set of developers of the Pharo open-source community. Our findings indicate that the notion of collaboration must be revisited, as it is undermined by a number of factors that are often tackled in imprecise ways or not taken into account at all.},
	keywords = {COLLABORATION, Software ecosystems},
	isbn = {978-1-4503-2863-0},
	doi = {10.1145/2597073.2597093},
	url = {http://doi.acm.org/10.1145/2597073.2597093},
	author = {Tymchuk, Yuriy and Mocci, Andrea and Lanza, Michele}
}
@article {9400325220140301,
	title = {COLLABORATION THROUGH OPEN SUPERPOSITION: A THEORY OF THE OPEN SOURCE WAY.},
	journal = {MIS Quarterly},
	volume = {38},
	number = {1},
	year = {2014},
	pages = {29 - A9},
	abstract = {This paper develops and illustrates the theory of collaboration through open superposition: the process of depositing motivationally independent layers of work on top of each other over time. The theory is developed in a study of community-based free and open source software (FLOSS) development, through a research arc of discovery (participant observation), replication (two archival case studies), and theorization. The theory explains two key findings: (1) the overwhelming majority of work is accomplished with only a single programmer working on any one task, and (2) tasks that appear too large for any one individual are more likely to be deferred until they are easier rather than being undertaken through structured team work. Moreover, the theory explains how working through open superposition can lead to the discovery of a work breakdown that results in complex, functionally interdependent, work being accomplished without crippling search costs. We identify a set of socio-technical},
	keywords = {COLLABORATION, COMPUTER programmers, COMPUTER programming, COMPUTER software, coordination, FREEWARE (Computer software), INFORMATION storage \& retrieval systems, open source software, research, socio-technical system},
	issn = {02767783},
	author = {Howison, James and Kevin Crowston}
}
@conference {Rozas:2014:DCP:2641580.2641624,
	title = {Drupal As a Commons-Based Peer Production Community: A Sociological Perspective},
	booktitle = {Proceedings of The International Symposium on Open Collaboration},
	series = {OpenSym {\textquoteright}14},
	year = {2014},
	pages = {36:1{\textendash}36:2},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {The aim of this research consists of extracting a set of insights related to the dynamics, group decision making procedures, motivations to contribute and mechanisms employed in the coordination of Commons-Based Peer Production communities, using as a case study the community responsible for the development of the Free/Libre Open Source Software Drupal. A sociological perspective is taken for this purpose, and a set of social research qualitative and quantitative methods employed for the study of online communities (virtual ethnography) are being used.
},
	keywords = {Activity Theory, Commons-Based Peer Production, drupal, Free/Libre Open Source Software, Virtual Ethnography},
	isbn = {978-1-4503-3016-9},
	doi = {10.1145/2641580.2641624},
	url = {http://doi.acm.org/10.1145/2641580.2641624},
	author = {Rozas, David}
}
@inbook {1615,
	title = {An Exploration of Code Quality in FOSS Projects},
	booktitle = {Open Source Software: Mobile Open Source Technologies},
	series = {IFIP Advances in Information and Communication Technology},
	volume = {427},
	year = {2014},
	pages = {181-190},
	publisher = {Springer Berlin Heidelberg},
	organization = {Springer Berlin Heidelberg},
	abstract = {

It is a widely held belief that Free/Open Source Software (FOSS) development leads to the creation of software with the same, if not higher quality compared to that created using proprietary software development models. However there is little research on evaluating the quality of FOSS code, and the impact of project characteristics such as age, number of core developers, code-base size, etc. In this exploratory study, we examined 110 FOSS projects, measuring the quality of the code and architectural design using code smells. We found that, contrary to our expectations, the overall quality of the code is not affected by the size of the code base, but that it was negatively impacted by the growth of the number of code contributors. Our results also show that projects with more core developers don{\textquoteright}t necessarily have better code quality.
},
	keywords = {Code Quality, FOSS, open source software, success metrics},
	isbn = {978-3-642-55127-7},
	doi = {10.1007/978-3-642-55128-4_26},
	url = {http://dx.doi.org/10.1007/978-3-642-55128-4_26},
	author = {Ahmed, Iftekhar and Ghorashi, Soroush and Jensen, Carlos},
	editor = {Corral, Luis and Sillitti, Alberto and Succi, Giancarlo and Vlasenko, Jelena and Wasserman, AnthonyI.}
}
@inbook {1594,
	title = {How Do Social Interaction Networks Influence Peer Impressions Formation? A Case Study},
	booktitle = {Open Source Software: Mobile Open Source Technologies},
	series = {IFIP Advances in Information and Communication Technology},
	volume = {427},
	year = {2014},
	pages = {31-40},
	publisher = {Springer Berlin Heidelberg},
	organization = {Springer Berlin Heidelberg},
	abstract = {Due to their lack of physical interaction, Free and Open Source Software (FOSS) participants form impressions of their teammates largely based on sociotechnical mechanisms including: code commits, code reviews, mailing-lists, and bug comments. These mechanisms may have different effects on peer impression formation. This paper describes a social network analysis of the WikiMedia project to determine which type of interaction has the most favorable characteristics for impressions formation. The results suggest that due to lower centralization, high interactivity, and high degree of interactions between participants, the code review interactions have the most favorable characteristics to support impression formation among FOSS participants.},
	keywords = {COLLABORATION, FOSS, open source, OSS, social network analysis},
	isbn = {978-3-642-55127-7},
	doi = {10.1007/978-3-642-55128-4_4},
	url = {http://dx.doi.org/10.1007/978-3-642-55128-4_4},
	author = {Bosu, Amiangshu and Carver, JeffreyC.},
	editor = {Corral, Luis and Sillitti, Alberto and Succi, Giancarlo and Vlasenko, Jelena and Wasserman, AnthonyI.}
}
@conference {Vasilescu:2014:SQS:2531602.2531659,
	title = {How Social Q\&A Sites Are Changing Knowledge Sharing in Open Source Software Communities},
	booktitle = {Proceedings of the 17th ACM Conference on Computer Supported Cooperative Work \&\#38; Social Computing},
	series = {CSCW {\textquoteright}14},
	year = {2014},
	pages = {342{\textendash}354},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {Historically, mailing lists have been the preferred means for coordinating development and user support activities. With the emergence and popularity growth of social Q\&A sites such as the StackExchange network (e.g., StackOverflow), this is beginning to change. Such sites offer different socio-technical incentives to their participants than mailing lists do, e.g., rich web environments to store and manage content collaboratively, or a place to showcase their knowledge and expertise more vividly to peers or potential recruiters. A key difference between StackExchange and mailing lists is gamification, i.e., StackExchange participants compete to obtain reputation points and badges. In this paper, we use a case study of R (a widely-used tool for data analysis) to investigate how mailing list participation has evolved since the launch of StackExchange. Our main contribution is the assembly of a joint data set from the two sources, in which participants in both the texttt{r-help} mailing list and StackExchange are identifiable. This permits their activities to be linked across the two resources and also over time. With this data set we found that user support activities show a strong shift away from texttt{r-help}. In particular, mailing list experts are migrating to StackExchange, where their behaviour is different. First, participants active both on texttt{r-help} and on StackExchange are more active than those who focus exclusively on only one of the two. Second, they provide faster answers on StackExchange than on texttt{r-help}, suggesting they are motivated by the emph{gamified} environment. To our knowledge, our study is the first to directly chart the changes in behaviour of specific contributors as they migrate into gamified environments, and has important implications for knowledge management in software engineering.},
	keywords = {a, crowdsourced knowledge, gamification., mailing lists, open source, social q\&\#38},
	isbn = {978-1-4503-2540-0},
	doi = {10.1145/2531602.2531659},
	url = {http://doi.acm.org/10.1145/2531602.2531659},
	attachments = {https://flosshub.org/sites/flosshub.org/files/cscw14.pdf},
	author = {Vasilescu, Bogdan and Serebrenik, Alexander and Devanbu, Prem and Filkov, Vladimir}
}
@conference {Rahman:2014:IPR:2597073.2597121,
	title = {An Insight into the Pull Requests of GitHub},
	booktitle = {Proceedings of the 11th Working Conference on Mining Software Repositories},
	series = {MSR 2014},
	year = {2014},
	pages = {364{\textendash}367},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {Given the increasing number of unsuccessful pull requests in GitHub projects, insights into the success and failure of these requests are essential for the developers. In this paper, we provide a comparative study between successful and unsuccessful pull requests made to 78 GitHub base projects by 20,142 developers from 103,192 forked projects. In the study, we analyze pull request discussion texts, project specific information (e.g., domain, maturity), and developer specific information (e.g., experience) in order to report useful insights, and use them to contrast between successful and unsuccessful pull requests. We believe our study will help developers overcome the issues with pull requests in GitHub, and project administrators with informed decision making.
},
	keywords = {Commit comments, mining challenge, msr challenge, pull request, topic model},
	isbn = {978-1-4503-2863-0},
	doi = {10.1145/2597073.2597121},
	url = {http://doi.acm.org/10.1145/2597073.2597121},
	attachments = {https://flosshub.org/sites/flosshub.org/files/rahman.pdf},
	author = {Rahman, Mohammad Masudur and Chanchal K. Roy}
}
@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 {Kalliamvakou:2014:PPM:2597073.2597074,
	title = {The Promises and Perils of Mining GitHub},
	booktitle = {Proceedings of the 11th Working Conference on Mining Software Repositories},
	series = {MSR 2014},
	year = {2014},
	pages = {92{\textendash}101},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {With over 10 million git repositories, GitHub is becoming one of the most important source of software artifacts on the Internet. Researchers are starting to mine the information stored in GitHub{\textquoteright}s event logs, trying to understand how its users employ the site to collaborate on software. However, so far there have been no studies describing the quality and properties of the data available from GitHub. We document the results of an empirical study aimed at understanding the characteristics of the repositories in GitHub and how users take advantage of GitHub{\textquoteright}s main features---namely commits, pull requests, and issues. Our results indicate that, while GitHub is a rich source of data on software development, mining GitHub for research purposes should take various potential perils into consideration. We show, for example, that the majority of the projects are personal and inactive; that GitHub is also being used for free storage and as a Web hosting service; and that almost 40\% of all pull requests do not appear as merged, even though they were. We provide a set of recommendations for software engineering researchers on how to approach the data in GitHub.
},
	keywords = {bias, code reviews, git, github, mining software repositories},
	isbn = {978-1-4503-2863-0},
	doi = {10.1145/2597073.2597074},
	url = {http://doi.acm.org/10.1145/2597073.2597074},
	attachments = {https://flosshub.org/sites/flosshub.org/files/perils.pdf},
	author = {Kalliamvakou, Eirini and Gousios, Georgios and Blincoe, Kelly and Singer, Leif and Daniel M. German and Damian, Daniela}
}
@conference {Padhye:2014:SEC:2597073.2597113,
	title = {A Study of External Community Contribution to Open-source Projects on GitHub},
	booktitle = {Proceedings of the 11th Working Conference on Mining Software Repositories},
	series = {MSR 2014},
	year = {2014},
	pages = {332{\textendash}335},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {Open-source software projects are primarily driven by community contribution. However, commit access to such projects{\textquoteright} software repositories is often strictly controlled. These projects prefer to solicit external participation in the form of patches or pull requests. In this paper, we analyze a set of 89 top-starred GitHub projects and their forks in order to explore the nature and distribution of such community contribution. We first classify commits (and developers) into three categories: core, external and mutant, and study the relative sizes of each of these classes through a ring-based visualization. We observe that projects written in mainstream scripting languages such as JavaScript and Python tend to include more external participation than projects written in upcoming languages such as Scala. We also visualize the geographic spread of these communities via geocoding. Finally, we classify the types of pull requests submitted based on their labels and observe that bug fixes are more likely to be merged into the main projects as compared to feature enhancements.
},
	keywords = {community participation, core committers, external contribution, mining challenge, mining software repositories, msr challenge, Open-source software, pull requests},
	isbn = {978-1-4503-2863-0},
	doi = {10.1145/2597073.2597113},
	url = {http://doi.acm.org/10.1145/2597073.2597113},
	author = {Padhye, Rohan and Mani, Senthil and Sinha, Vibha Singhal}
}
@conference {Teixeira:2014:UCO:2641580.2641627,
	title = {Understanding Coopetition in the Open-Source Arena: The Cases of WebKit and OpenStack},
	booktitle = {Proceedings of The International Symposium on Open Collaboration},
	series = {OpenSym {\textquoteright}14},
	year = {2014},
	pages = {39:1{\textendash}39:5},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {In an era of software crisis, the move of firms towards distributed software development teams is being challenged by emerging collaboration issues. On this matter, the open-source phenomenon may shed some light, as successful cases on distributed collaboration in the open-source community have been recurrently reported. In our research we explore collaboration networks in the WebKit and OpenStack high-networked open-source projects, by mining their source-code version-control-systems data with Social Network Analysis (SNA). Our approach allows us to observe how key events in the industry affect open-source collaboration networks over time. With our findings, we highlight the explanatory power from network visualizations capturing the collaborative dynamics of high-networked software projects over time. Moreover, we argue that competing companies that sell similar products in the same market, can collaborate in the open-source community while publicly manifesting intense rivalry (e.g. Apple vs Samsung patent-wars). After integrating our findings with the current body of theoretical knowledge in management strategy, economics, strategic alliances and coopetition, we propose the novel notion of open-coopetition, where rival firms collaborate with competitors in the open-source community. We argue that classical coopetition management theories do not fully explain the competitive and collaborative issues that are simultaneously present and interconnected in the WebKit and OpenStack open-source communities. We propose the development of the novel open-coopetition theory for a better understanding on how rival-firms collaborate with competitors by open-source manners.
},
	keywords = {COLLABORATION, Competition, Coopetition, Ecosystems, FLOSS, Open-Coopetition, open-source, OSS, Strategic Alliances},
	isbn = {978-1-4503-3016-9},
	doi = {10.1145/2641580.2641627},
	url = {http://doi.acm.org/10.1145/2641580.2641627},
	author = {Teixeira, Jose}
}
@conference {Barcomb:2014:VAR:2641580.2641628,
	title = {Volunteer Attraction and Retention in Open Source Communities},
	booktitle = {Proceedings of The International Symposium on Open Collaboration},
	series = {OpenSym {\textquoteright}14},
	year = {2014},
	pages = {40:1{\textendash}40:2},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {The importance of volunteers in open source has led to the position of community manager becoming more common in foundations and projects. Yet the advice for volunteer management and retention is fragmented, incomplete, contradictory, and has not been empirically examined. Our aim is to fill this gap by creating a comprehensive guidebook of best practices drawing from open source practitioner guides and general literature on volunteering, and to subject a subset of practices to empirical study. A method for evaluating volunteer attrition in terms of value to the organization will also be developed.
},
	keywords = {Community Management, FLOSS, open source, Recruitment, Service Duration, Volunteer Management, Volunteer Retention, Volunteers},
	isbn = {978-1-4503-3016-9},
	doi = {10.1145/2641580.2641628},
	url = {http://doi.acm.org/10.1145/2641580.2641628},
	author = {Barcomb, Ann}
}
@proceedings {1552,
	title = {Analyzing Social Behavior of Software Developers Across Different Communication Channels},
	year = {2013},
	abstract = {Software developers use different project repositories (i.e., mailing list, bug tracking repositories, discussion forums etc.) to interact with each other or to solve software related problems. The growing interest in the usage of social media channels (i.e., Twitter, Facebook, LinkedIn) have also attracted the open source software community and software developers to adopt an identity in order to disseminate project-related information to a wider audience. Much research has been carried out to analyze the social behavior of software developers in different project repositories but so far no one has tried to study the social communication patterns of developers in other social media channels. We in this paper presents a new dimension to the social aspects of software developers and study if the social communication patterns of software developers is different on project repositories and social media channels (i.e., Twitter).},
	keywords = {communication, developer, social media},
	url = {http://index.ksi.edu/conf/seke/2013/cr/296.pdf},
	attachments = {https://flosshub.org/sites/flosshub.org/files/iqbal_a_et_al_june_2013.pdf},
	author = {Iqbal, Aftab and M Karnstedt and M Hausenblas}
}
@book {1579,
	title = {Finding Source Code on the Web for Remix and Reuse},
	series = {Infrastructure for Building Code Search Applications for Developers},
	year = {2013},
	note = {In "further reading": "Although not a code search infrastructure, FLOSSmole [13] is another major undertaking
in building large collection of metadata about open source projects on the
Web. Currently, FLOSSmole reports a massive data collection of more than 500,000
open source projects in its web site [32]. For code search infrastructure builders,
now it is possible to leverage FLOSSmole{\textquoteright}s project metadata to build code repositories
instead of spending an effort in implementing custom spiders and crawlers for
code."},
	pages = {135 - 164},
	publisher = {Springer New York},
	organization = {Springer New York},
	address = {New York, NY},
	abstract = {The large availability of open source code on the Web provides great opportunities to build useful code search applications for developers. Building such applications requires addressing several challenges inherent in collecting and analyzing code from open source repositories to make them available for search. An infrastructure that supports collection, analysis, and search services for open source code available on the Web can greatly facilitate building effective code search applications. This chapter presents such an infrastructure called Sourcerer that facilitates collection, analysis, and search of source code available in code repositories on the Web. This chapter provides useful information to researchers and implementors of code search applications interested in harnessing the large availability of source code in the repositories on the Web. In particular, this chapter highlights key aspects of Sourcerer that supports combining Software Engineering and Information Retrieval techniques to build effective code search applications.},
	keywords = {code search, flossmole cited},
	isbn = {978-1-4614-6596-6},
	doi = {10.1007/978-1-4614-6596-6_8},
	url = {http://www.drsusansim.org/papers/FindingCodeontheWeb-20120822.pdf},
	author = {Bajracharya, Sushil Krishna},
	editor = {Sim, Susan Elliott and Gallardo-Valencia, Rosalva E.}
}
@proceedings {1510,
	title = {A Historical Dataset for the Gnome Ecosystem},
	year = {2013},
	month = {05/2013},
	abstract = {We present a dataset of the open source software ecosystem Gnome from a social point of view. We have collected historical data about the contributors to all Gnome projects stored on git.gnome.org, taking into account the problem of identity matching, and associating different activity types to the contributors. This type of information is very useful to complement the traditional, source-code related information one can obtain by mining and analyzing the actual source code. The dataset can be obtained at https://bitbucket.org/mgoeminne/sgl-flossmetric-dbmerge.},
	keywords = {cvsanaly, flossmetrics, gnome},
	author = {Mathieu Goeminne and Ma{\"e}lick Claes and Mens, Tom}
}
@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.}
}
@article {bettenburg2013management,
	title = {Management of community contributions},
	journal = {Empirical Software Engineering},
	year = {2013},
	pages = {1{\textendash}38},
	publisher = {Springer},
	abstract = {In recent years, many companies have realized that collaboration with a thriving user or developer community is a major factor in creating innovative technology driven by market demand. As a result, businesses have sought ways to stimulate contributions from developers outside their corporate walls, and integrate external developers into their development process. To support software companies in this process, this paper presents an empirical study on the contribution management processes of two major, successful, open source software ecosystems. We contrast a for-profit (ANDROID) system having a hybrid contribution style, with a not-for-profit (LINUX kernel) system having an open contribution style. To guide our comparisons, we base our analysis on a conceptual model of contribution management that we derived from a total of seven major open-source software systems. A quantitative comparison based on data mined from the ANDROID code review system and the LINUX kernel code review mailing lists shows that both projects have significantly different contribution management styles, suited to their respective market goals, but with individual advantages and disadvantages that are important for practitioners. Contribution management is a real-world problem that has received very little attention from the research community so far. Both studied systems (LINUX and ANDROID) employ different strategies and techniques for managing contributions, and both approaches are valuable examples for practitioners. Each approach has specific advantages and disadvantages that need to be carefully evaluated by practitioners when adopting a contribution management process in practice.},
	keywords = {android, contribution, linux, management},
	url = {http://link.springer.com/article/10.1007/s10664-013-9284-6},
	author = {Bettenburg, Nicolas and Hassan, Ahmed E. and Adams, Bram and Daniel M. German}
}
@article {IJC397,
	title = {Preliminary steps toward a general theory of internet-based collective-action in digital information commons: Findings from a study of open source software projects},
	journal = {International Journal of the Commons},
	volume = {7},
	number = {2},
	year = {2013},
	abstract = {This paper presents some of the findings from a 5-year empirical study of FOSS (free/libre and open source software) commons, completed in 2011. FOSS projects are Internet-based common property regimes where the project source code is developed over the Internet. The resulting software is generally distributed with a license that provides users with the freedoms to access, use, read, modify and redistribute the software. In this study we used three different and very large datasets (approximately 107,000; 174,000 and 1400 cases respectively) with information on FOSS projects residing in Sourceforge.net, one of the largest, if not the largest, FOSS repository in the world. We employ various quantitative methods to uncover factors that lead some FOSS projects to ongoing collaborative success, while others become abandoned. After presenting some of our study{\textquoteright}s results, we articulate the collaborative {\textquotedblleft}story{\textquotedblright} of FOSS that emerged. We close the paper by discussing some key findings that can contribute to a general theory of Internet-based collective-action and FOSS-like forms of digital online commons.},
	keywords = {collaborative success and abandonment, common property regime, digital information commons, flossmole, Free/libre software, open source software, sourceforge, srda},
	issn = {1875-0281},
	url = {http://www.thecommonsjournal.org/index.php/ijc/article/view/URN\%3ANBN\%3ANL\%3AUI\%3A10-1-114926},
	author = {Charles Schweik and Robert English}
}
@conference {Scacchi:2013:PSO:2486046.2486068,
	title = {Processes in Securing Open Architecture Software Systems},
	booktitle = {Proceedings of the 2013 International Conference on Software and System Process},
	series = {ICSSP 2013},
	year = {2013},
	pages = {126{\textendash}135},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {Our goal is to identify and understand issues that arise in the development and evolution processes for securing open architecture (OA) software systems. OA software systems are those developed with a mix of closed source and open source software components that are configured via an explicit system architectural specification. Such a specification may serve as a reference model or product line model for a family of concurrently sustained OA system versions/variants. We employ a case study focusing on an OA software system whose security must be continually sustained throughout its ongoing development and evolution. We limit our focus to software processes surrounding the architectural design, continuous integration, release deployment, and evolution found in the OA system case study. We also focus on the role automated tools, software development support mechanisms, and development practices play in facilitating or constraining these processes through the case study. Our purpose is to identify issues that impinge on modeling (specification) and integration of these processes, and how automated tools mediate these processes, as emerging research problems areas for the software process research community. Finally, our study is informed by related research found in the prescriptive versus descriptive practice of these processes and tool usage in studies of conventional and open source software development projects.},
	keywords = {configuration, continuous software development, Open architecture, process integration, process modeling, security},
	isbn = {978-1-4503-2062-7},
	doi = {10.1145/2486046.2486068},
	url = {http://doi.acm.org/10.1145/2486046.2486068},
	attachments = {https://flosshub.org/sites/flosshub.org/files/Scacchi-Alspaugh-ICSSP13.pdf},
	author = {Walt Scacchi and Alspaugh, Thomas A.}
}
@proceedings {1561,
	title = {A Replicable Infrastructure for Empirical Studies of Email Archives},
	year = {2013},
	month = {10/2013},
	pages = {43-50},
	publisher = {IEEE},
	address = {Baltimore, MD, USA},
	abstract = {This paper describes a replicable infrastructure solution for conducting empirical software engineering studies based on email mailing list archives. Mailing list emails, such as those affiliated with free, libre, and open source software (FLOSS) projects, are currently archived in several places online, but each research team that wishes to study these email artifacts closely must design their own solution for collection, storage and cleaning of the data. Consequently, research results will be difficult to replicate, especially as the email archive for any living project will still be continually growing. This paper describes a simple, replicable infrastructure for the collection, storage, and cleaning of project email data and analyses.},
	keywords = {apache, cleaning, collection, couchdb, database, document-oriented database, email, lucene, mailing lists, nosql, replication, storage},
	isbn = {978-0-7695-5121-0},
	attachments = {https://flosshub.org/sites/flosshub.org/files/RESERv2.pdf},
	author = {Squire, Megan}
}
@proceedings {1498,
	title = {Who Does What during a Code Review? Datasets of OSS Peer Review Repositories },
	year = {2013},
	month = {05/2013},
	abstract = {We present four datasets that are focused on the general roles of OSS peer review members. With data mined from both an integrated peer review system and code source repositories, our rich datasets comprise of peer review data that was automatically recorded. Using the Android project as a case study, we describe our extraction methodology, the datasets and their application used for three separate studies. Our datasets are available online at http://sdlab.naist.jp/reviewmining/},
	keywords = {android, case study, code review, data set, peer review, roles, source code},
	author = {Kazuki Hamasaki and Raula Gaikovina Kula and Norihiro Yoshida and A. E. Camargo Cruz and Kenji Fujiwara and Hajimu Iida}
}
@article {1400,
	title = {Analyzing and mining a code search engine usage log},
	journal = {Empirical Software Engineering},
	volume = {17},
	year = {2012},
	month = {8/2012},
	pages = {424 - 466},
	abstract = {This paper presents an analysis of a year long usage log of Koders, the first commercially available Internet-Scale code search engine (http://www.koders.com). The usage log comprises about ten million activities from more than three million users. Analysis of the usage data shows that despite of attracting a large number of visitors, Koders has a very sparse usage and that it lacks regular usage from many of its users. When compared to Web search, search behavior in Koders showed many similar patterns. A topic modeling analysis of the usage data shows what topics users of Koders are looking for. Observations on the prevalence of these topics among the users, and observations on how search and download activities vary across topics, lead to the conclusion that users who find code search engines usable are those who already know to a high level of specificity what to look for. This paper also presents a general categorization of these topics that provides insights on the different ways code search engine users express their queries. It identifies various forms of queries in Koders{\textquoteright}s log and the kinds of results addressed by the queries. It also provides several suggestions for improvements in code search engines based on the analysis of usage, topics, and query forms. The work presented in this paper is the first of its kind that reveals several insights on the usage of an Internet-Scale code search engine.},
	keywords = {code search, koders, search, search engine, topics},
	issn = {1573-7616},
	doi = {10.1007/s10664-010-9144-6},
	author = {Bajracharya, Sushil Krishna and Lopes, Cristina Videira}
}
@proceedings {1445,
	title = {Emerging Hackerspaces {\textendash} Peer-Production Generation},
	volume = {378},
	year = {2012},
	month = {09/2012},
	pages = {94-111},
	publisher = {IFIP AICT},
	abstract = {This paper describes a peer-production movement, the hackerspace movement, its members and values. The emergence of hackerspaces, fablabs and makerspaces is changing how hacker communities and other like-minded communities function. Thus, an understanding of the nature of hackerspaces helps in detailing the features of contemporary peer-production. Building on previous work on {\textquoteright}fabbing{\textquoteright}, two different sets of results are presented: (1) empirical observations from a longitudinal study of hackerspace participants; and (2) a theoretical description of hacker generations as a larger context in which peer-production can be located. With regard to (1), research data has been collected through prolonged observation of hackerspace communities and two surveys.},
	keywords = {COMMUNITY, fabbing, fablab, hackerspace, makerspace, MOTIVATION, movement, open source, peer-production, Survey, sustainability},
	author = {Moilanen, Jarkko}
}
@proceedings {1451,
	title = {Exploring the Role of Outside Organizations in Free / Open Source Software Projects},
	volume = {378},
	year = {2012},
	month = {09/2012},
	pages = {201-215},
	publisher = {IFIP AICT},
	abstract = {Free/Open Source Software (FOSS) projects have a reputation for being grass-roots efforts driven by individual contributors volunteering their time and effort. While this may be true for a majority of smaller projects, it is not always the case for large projects. As projects grow in size, importance and complexity, many come to depend on corporations, universities, NGO{\textquoteright}s and governments, for support and contributions, either financially or through seconded staff. As outside organizations get involved in projects, how does this affect their governance, transparency and direction? To study this question we gathered bug reports and commit logs for GCC and the Linux Kernel. We found that outside organizations contribute a majority of code but rarely participate in bug triaging. Therefore their code does not necessarily address the needs of others and may distort governance and direction. We conclude that projects should examine their dependence on outside organizations},
	keywords = {bug reports, commit, Community sustainability, Contributor affiliation, gcc, governance, linux kernel, Participation metrics},
	url = {http://research.engr.oregonstate.edu/hci/sites/research.engr.oregonstate.edu.hci/files/papers/forrest2012exploring.pdf},
	author = {Forrest, Darren and Jensen, Carlos and Mohan, Nitin and Davidson, Jennifer}
}
@article {1879,
	title = {Linux Kernel Development: How Fast it is Going, Who is Doing It, What They are Doing, and Who is Sponsoring It},
	year = {2012},
	month = {03/2012},
	institution = {The Linux Foundation},
	abstract = {The kernel which forms the core of the Linux system is the result of one of the largest cooperative software projects ever attempted. Regular 2-3 month releases deliver stable updates to Linux users, each with signi cant new features, added device support, and improved performance. The rate of change in the kernel is high and increasing, with between 8,000 and 12,000 patches going into each recent kernel release. These releases each contain the work of over 1,000 developers representing nearly 200 corporations.
Since 2005, over 7,800 individual developers from almost 800 different companies have contributed to the kernel. The Linux kernel, thus, has become a common resource developed on a massive scale by companies which are  erce competitors in other areas.
This is the fourth update of this document, which has been published roughly annually since 2008. It covers development through the 3.2 release, with an emphasis on the releases (2.6.36 to 3.2) made since the last update. It has been a busy period, with seven kernel releases created, many signi cant changes made, and continual growth of the kernel developer and user community.
},
	keywords = {corporate, corporations, developers, linux kernel, metrics},
	attachments = {https://flosshub.org/sites/flosshub.org/files/lf_kernel_development_2012.pdf},
	author = {Corbet, Jonathan and Greg Kroah-Hartman and Amanda McPherson}
}
@proceedings {1456,
	title = {A Qualitative Method for Mining Open Source Software Repositories},
	volume = {378},
	year = {2012},
	note = {The method proposed by this study employs content analysis Krippendorff [10], a classification technique that is frequently applied to interview and focus group data. The objective of content analysis is to ask quantitative questions about qualitative data. The approach is similar to the grounded theory method, but differs from grounded theory in that the results are quantitative rather than qualitative: content analysis produces results such as, {\textquotedblleft}49\% of messages submitted to project mailing lists were sent by core developers.{\textquotedblright}},
	month = {09/2012},
	pages = {256-261},
	publisher = {IFIP AICT,  Springer},
	abstract = {The volume of data archived in open source software project repositories makes automated, quantitative techniques attractive for extracting and analyzing information from these archives. However, many kinds of archival data include blocks of natural language text that are difficult to analyze automatically.

This paper introduces a qualitative analysis method that is transparent and repeatable, leads to objective findings when dealing with qualitative data, and is efficient enough to be applied to large archives.

The method was applied in a case study of developer and user forum discussions of an open source electronic medical record project. The study demonstrates that the qualitative repository mining method can be employed to derive useful results quickly yet accurately. These results would not be possible using a strictly automated approach.},
	keywords = {content analysis, Electronic Medical Record, Qualitative Research},
	author = {Noll, John and Seichter, Dominik and Beecham, Sarah}
}
@mastersthesis {1438,
	title = {Software Libre y abierto: comunidades y redes de producción digital de bienes comunes},
	year = {2012},
	pages = {269 pages},
	school = {Universidad Nacional Autónoma de México},
	address = {Ciudad de México, México},
	abstract = {This thesis is about a collective form of production that have expanded and strengthen in the global high technology market. It is about FLOSS production. 

The study takes on account that technnologies are not neutral, they emerge as strategies and mechanisms of politics and economic interests. 

Although, FLOSS production is inserted in the capitalist context, the collective work of the communities and networks that produce it is based on ideas about freedom and solidarity.

The types of rules and organization of labour inside of this communities have develop a kind of product that it is well categorized as part of the new commons.

The conclusions at the end of this work pretend to offer a clear approach to the FLOSS production networks dynamics inside the virtual infrastructure. Specifically, it offers an approach of the interaction and forms of cooperation, as well of the individual and collective schemas that motivates the cooperation action of the individuals.},
	keywords = {bienes comunes, commons, comunidades virtuales, FLOSS, flossmole, hackers, redes virtuales, repositories, repositorios, Software libre y abierto, virtual communities, virtual networks},
	url = {http://132.248.9.195/ptd2012/agosto/406008604/Index.html},
	attachments = {https://flosshub.org/sites/flosshub.org/files/Tesis.pdf},
	author = {Tania E. Turner Sen}
}
@proceedings {1288,
	title = {An Analysis of Author Contribution Patterns in Eclipse Foundation Project Source Code},
	year = {2011},
	note = {"We conducted an observational study on existing Eclipse projects by extracting author attribution data for Java source code files from git repositories."

"Specifically, we consider entropy of source code by counting the number of lines attributed to each author."},
	month = {10/2011},
	pages = {269-281},
	publisher = {Springer},
	abstract = {Collaborative development is a key tenet of open source software, but if not properly understood and managed, it can become a liability. We examine author contribution data for the newest revision of 251,633 Java source files in 592 Eclipse projects. We use this observational data to analyze collaboration patterns within files, and to explore relationships between file size, author count, and code authorship. We calculate author entropy to characterize the contributions of multiple authors to a given file, with an eye toward understanding the degree of collaboration and the most common interaction patterns.},
	keywords = {COLLABORATION, contribution, eclipse, entropy, java},
	author = {Taylor, Quinn C. and Krein, Jonathan L. and MacLean, Alexander C. and Knutson, Charles D.}
}
@proceedings {1278,
	title = {Building Knowledge in Open Source Software Research in Six Years of Conferences},
	year = {2011},
	note = {RQ1. Is there any social network underlying the research production at the OSS conference series?
RQ2. What are the major streams of research proposed at the OSS conference series?},
	month = {10/2011},
	pages = {123-141},
	publisher = {Springer},
	abstract = {Since its origins, the diffusion of the OSS phenomenon and the information about it has been entrusted to the Internet and its virtual communities of developers. This public mass of data has attracted the interest of researchers and practitioners aiming at formalizing it into a body of knowledge. To this aim, in 2005, a new series of conferences on OSS started to collect and convey OSS knowledge to the research and industrial community. Our work mines articles of the OSS conference series to understand the process of knowledge grounding and the community surrounding it. As such, we propose a semi-automated approach for a systematic mapping study on these articles. We automatically build a map of cross-citations among all the papers of the conferences and then we manually inspect the resulting clusters to identify knowledge building blocks and their mutual relationships. We found that industry-related, quality assurance, and empirical studies often originate or maintain new streams of research.},
	keywords = {Cross-citations, flossmole cited, graph, literature review, network, research, Systematic Mapping Study},
	author = {Mulazzini, Fabio and Rossi, Bruno and Russo, Barbara and Steff, Maximilian}
}
@proceedings {1289,
	title = {Cliff Walls: An Analysis of Monolithic Commits Using Latent Dirichlet Allocation},
	year = {2011},
	note = {"Our data set consists of the version control logs of almost 10,000 projects from SourceForge, acquired in late 2006"},
	month = {10/2011},
	pages = {282-298},
	publisher = {Springer},
	abstract = {Artifact-based research provides a mechanism whereby researchers may study the creation of software yet avoid many of the difficulties of direct observation and experimentation. However, there are still many challenges that can affect the quality of artifact-based studies, especially those studies examining software evolution. Large commits, which we refer to as {\textquotedblleft}Cliff Walls,{\textquotedblright} are one significant threat to studies of software evolution because they do not appear to represent incremental development. We used Latent Dirichlet Allocation to extract topics from over 2 million commit log messages, taken from 10,000 SourceForge projects. The topics generated through this method were then analyzed to determine the causes of over 9,000 of the largest commits. We found that branch merges, code imports, and auto-generated documentation were significant causes of large commits. We also found that corrective maintenance tasks, such as bug fixes, did not play a significant role in the creation of large commits.},
	keywords = {artifacts, commit, cvs, LDA, lines of code, log files, scm, sloc, sourceforge, version control},
	author = {Pratt, Landon J. and MacLean, Alexander C. and Knutson, Charles D. and Ringger, Eric K.}
}
@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}
}
@article {1418,
	title = {Effort estimation of FLOSS projects: a study of the Linux kernel},
	journal = {Empirical Software Engineering},
	year = {2011},
	pages = {1-29},
	abstract = {Empirical research on Free/Libre/Open Source Software (FLOSS) has shown that developers tend to cluster around two main roles: {\textquotedblleft}core{\textquotedblright} contributors differ from {\textquotedblleft}peripheral{\textquotedblright} developers in terms of a larger number of responsibilities and a higher productivity pattern. A further, cross-cutting characterization of developers could be achieved by associating developers with {\textquotedblleft}time slots{\textquotedblright}, and different patterns of activity and effort could be associated to such slots. Such analysis, if replicated, could be used not only to compare different FLOSS communities, and to evaluate their stability and maturity, but also to determine within projects, how the effort is distributed in a given period, and to estimate future needs with respect to key points in the software life-cycle (e.g., major releases). This study analyses the activity patterns within the Linux kernel project, at first focusing on the overall distribution of effort and activity within weeks and days; then, dividing each day into three 8-hour time slots, and focusing on effort and activity around major releases. Such analyses have the objective of evaluating effort, productivity and types of activity globally and around major releases. They enable a comparison of these releases and patterns of effort and activities with traditional software products and processes, and in turn, the identification of company-driven projects (i.e., working mainly during office hours) among FLOSS endeavors. The results of this research show that, overall, the effort within the Linux kernel community is constant (albeit at different levels) throughout the week, signalling the need of updated estimation models, different from those used in traditional 9am{\textendash}5pm, Monday to Friday commercial companies. It also becomes evident that the activity before a release is vastly different from after a release, and that the changes show an increase in code complexity in specific time slots (notably in the late night hours), which will later require additional maintenance efforts.},
	keywords = {complexity, effort estimation, Effort models, mining software repositories, open source software},
	issn = {1573-7616},
	doi = {10.1007/s10664-011-9191-7},
	url = {http://www.springerlink.com/content/612r616k8t52m867/fulltext.html},
	author = {Capiluppi, Andrea and Izquierdo-Cort{\'a}zar, Daniel}
}
@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}
}
@proceedings {1270,
	title = {Impact of Stakeholder Type and Collaboration on Issue Resolution Time in OSS Projects},
	year = {2011},
	note = {"First, we characterize the difference in the average amount of resolved issues and issue resolution time between a volunteer assignee and a firm-paid assignee....Second, we investigate collaboration among stakeholders in OSS projects by using Social network metrics and analysis. Last, we explore the impact of the collaboration measures on issue resolution time."

"Three OSS projects were selected for our study, namely Qt, Qpid and Geronimo"

"All software issues were collected from JIRA repositories...Issue resolution time was computed by using the created time field and the issue resolved time field."},
	month = {10/2011},
	pages = {1-16},
	publisher = {Springer},
	abstract = {Initialized by a collective contribution of volunteer developers, Open source software (OSS) attracts an increasing involvement of commercial firms. Many OSS projects are composed of a mix group of firm-paid and volunteer developers, with different motivations, collaboration practices and working styles. As OSS development consists of collaborative works in nature, it is important to know whether these differences have an impact on collaboration between difference types of stakeholders, which lead to an influence in the project outcomes. In this paper, we empirically investigate the firm-paid participation in resolving OSS evolution issues, the stakeholder collaboration and its impact on OSS issue resolution time. The results suggest that though a firm-paid assigned developer resolves much more issues than a volunteer developer does, there is no difference in issue resolution time between them. Besides, the more important factor that influences the issue resolution time comes from the collaboration among stakeholders rather than from individual characteristics.},
	keywords = {COLLABORATION, companies, coordination, defects, feature requests, geronimo, jira, qpid, qt, social network analysis, volunteer},
	author = {Duc, Ach Nguyen and Cruzes, Daniela S. and Ayala, Claudia and Conradi, Reidar}
}
@proceedings {1279,
	title = {The Importance of Architectural Knowledge in Integrating Open Source Software},
	year = {2011},
	month = {10/2011},
	pages = {142-158},
	publisher = {Springer},
	abstract = {Open Source Software (OSS) is increasingly used in Component-Based Software Development (CBSD) of large software systems. An important issue in CBSD is selection of suitable components. Various OSS selection methods have been proposed, but most of them do not consider the software architecture aspects of OSS products. The Software Architecture (SA) research community refers to a product{\textquoteright}s architectural information, such as design decisions and underlying rationale, and used architecture patterns, as Architecture Knowledge (AK). In order to investigate the importance of AK of OSS components in integration, we conducted an exploratory empirical study. Based on in-depth interviews with 12 IT professionals, this paper presents insights into the following questions: 1) what AK of OSS is needed? 2) Why is AK of OSS needed? 3) Is AK of OSS generally available? And 4) what is the relative importance of AK? Based on these new insights, we provide a research agenda to further the research field of software architecture in OSS.},
	keywords = {architectural knowledge, component-based development, Open Source Software integration, OSS Integrator, software architecture, Survey},
	author = {Stol, Klaas-Jan and Ali Babar, Muhammad and Avgeriou, Paris}
}
@conference {Sethanandha:2011:IOS:1985793.1986018,
	title = {Improving open source software patch contribution process: methods and tools},
	booktitle = {Proceedings of the 33rd International Conference on Software Engineering},
	series = {ICSE {\textquoteright}11},
	year = {2011},
	pages = {1134{\textendash}1135},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {The patch contribution process (PCP) is very important to the sustainability of OSS projects. Nevertheless, there are several issues on patch contribution in mature OSS projects, which include time consuming process, lost and ignored patches, slow review process. These issues are recognized by researchers and OSS projects, but have not been addressed. In this dissertation, I apply Kanban method to guide process improvement and tools development to reduce PCP cycle time.},
	keywords = {coordination, free software, kanban, lean methods, open source software, patches, productivity},
	isbn = {978-1-4503-0445-0},
	doi = {10.1145/1985793.1986018},
	url = {http://doi.acm.org/10.1145/1985793.1986018},
	author = {Bhuricha Deen Sethanandha}
}
@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}
}
@proceedings {1277,
	title = {Knowledge Homogeneity and Specialization in the Apache HTTP Server Project},
	year = {2011},
	note = {"Our data set consists of the commit history and email archives for the Apache HTTP Server Project, spanning sixteen years (2/27/1995 - 1/31/2011)"

"we 1) mapped the committers to email records, 2) cleaned the email records to remove extraneous information, 3) identified topics of discussion in the resulting messages, and 4) constructed a social network model from committers and topics."

"If specialization exists within the httpd community, we should see distinct communities develop around topics. In addition, unique groups of developers should congregate around specialized subtopics. We examined the data from both angles: topical affinity and topic communities."
},
	month = {10/2011},
	pages = {106-122},
	publisher = {Springer},
	abstract = {We present an analysis of developer communication in the Apache HTTP Server project. Using topic modeling techniques we expose latent conceptual sub-communities arising from developer specialization within the greater developer population. However, we found that among the major contributors to the project, very little specialization exists. We present theories to explain this phenomenon, and suggest further research.},
	keywords = {apache, commits, developer, email, email archive, LDA, mailing list, revision control, revision history, scm, social network analysis, specialization, subversion, svn},
	url = {http://sequoia.cs.byu.edu/lab/files/pubs/MacLean2011a.pdf},
	attachments = {https://flosshub.org/sites/flosshub.org/files/MacLean2011a.pdf},
	author = {MacLean, Alexander C. and Pratt, Landon J. and Knutson, Charles D. and Ringger, Eric K.}
}
@proceedings {1281,
	title = {License Update and Migration Processes in Open Source Software Projects},
	year = {2011},
	note = {"The case studies in this report are part of an ongoing, multi-year research project discovering and modeling open source software processes. Our research methodology is ethnographically informed, applying a grounded theory to the analysis of artifacts found in OSS projects. The primary data sources in this study come from mailing list archives of the Apache and NetBeans projects."},
	month = {10/2011},
	pages = {177-195},
	publisher = {Springer},
	abstract = {Open source software (OSS) has increasingly been the subject of research efforts. Central to this focus is the nature under which the software can be distributed, used, and modified and the causes and consequent effects on software development, usage, and distribution. At present, we have little understanding of, what happens when these licenses change, what motivates such changes, and how new licenses are created, updated, and deployed. Similarly, little attention has been paid to the agreements under which contributions are made to OSS projects and the impacts of changes to these agreements. We might also ask these same questions regarding the licenses governing how individuals and groups contribute to OSS projects. This paper focuses on addressing these questions with case studies of processes by which the Apache Software Foundation{\textquoteright}s creation and migration to Version 2.0 of the Apache Software License and the NetBeans project{\textquoteright}s migration to the Joint Licensing Agreement.},
	keywords = {apache, case study, email, email archive, license evolution, mailing list, netbeans, open source, process},
	attachments = {https://flosshub.org/sites/flosshub.org/files/1.pdf},
	author = {Chris Jensen and Walt Scacchi}
}
@conference {Jergensen:2011:OPM:2025113.2025127,
	title = {The onion patch: migration in open source ecosystems},
	booktitle = {Proceedings of the 19th ACM SIGSOFT symposium and the 13th European conference on Foundations of software engineering},
	series = {ESEC/FSE {\textquoteright}11},
	year = {2011},
	pages = {70{\textendash}80},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {Past research established that individuals joining an Open Source community typically follow a socialization process called "the onion model": newcomers join a project by first contributing at the periphery through mailing list discussions and bug trackers and as they develop skill and reputation within the community they advance to central roles of contributing code and making design decisions. However, the modern Open Source landscape has fewer projects that operate independently and many projects under the umbrella of software ecosystems that bring together projects with common underlying components, technology, and social norms. Participants in such an ecosystems may be able to utilize a significant amount of transferrable knowledge when moving between projects in the ecosystem and, thereby, skip steps in the onion model. In this paper, we examine whether the onion model of joining and progressing in a standalone Open Source project still holds true in large project ecosystems and how the model might change in such settings.},
	keywords = {contribution model, open source software, project ecosystem},
	isbn = {978-1-4503-0443-6},
	doi = {10.1145/2025113.2025127},
	url = {http://doi.acm.org/10.1145/2025113.2025127},
	author = {Jergensen, Corey and Sarma, Anita and Wagstrom, Patrick}
}
@article {1384,
	title = {On qualitative methodologies and dispersed communities: Reflections on the process of investigating an open source community},
	journal = {Information and Software Technology},
	volume = {53},
	year = {2011},
	month = {9/2011},
	pages = {981 - 993},
	abstract = {Context

Qualitative methodologies hold much potential for building an understanding of the principles and practices of free and open source software (FOSS) communities. Yet there is a scarcity in the literature of discussions focused on the practical and methodological challenges of this particular research context.
Objective

This paper formulates and addresses a number of questions regarding the applicability of qualitative methodologies for the study of FOSS communities. It reflects on the challenges of such approaches as seen in previous research efforts and discusses how they manifest in research practice through a thorough description of a case study of a community called PyPy.
Method

The paper primarily discusses interpretive research approaches which are based on ethnographic data collection methods. The study under discussion was an exploratory case study utilizing multiple methods, including participant observation, virtual ethnography, and open-ended questionnaires. Grounded Theory was used for data analysis.
Results

Two broad sets of challenges are highlighted in relation to the multidimensionality of the FOSS phenomenon and the difficulty of qualitative analysis of activities in long-term context. Additional issues identified relate to potential problems with focus and the need for reflexivity, but also to the extent of the study and the importance of maintaining an active relationship with the core community group.
Conclusion

This paper provides an overview {\textendash} grounded in practical research experience and linked to insights from the literature {\textendash} of methodological issues in the specific research area of qualitative studies of FOSS communities, which up until now has been lacking.},
	keywords = {case study, Collaborative practice, Distributed software development, Free open source communities, Qualitative methodologies},
	issn = {09505849},
	doi = {10.1016/j.infsof.2011.01.012},
	url = {http://www.sciencedirect.com/science/article/pii/S0950584911000413},
	author = {Sigfridsson, Anders and Sheehan, Anne}
}
@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}
}
@proceedings {1280,
	title = {Successful Reuse of Software Components: A Report from the Open Source Perspective},
	year = {2011},
	month = {10/2011},
	pages = {159-176},
	publisher = {Springer},
	abstract = {A promising way of software reuse is Component-Based Software Development (CBSD). There is an increasing number of OSS products available that can be freely used in product development. However, OSS communities themselves have not yet taken full advantage of the {\textquotedblleft}reuse mechanism{\textquotedblright}. Many OSS projects duplicate effort and code, even when sharing the same application domain and topic. One successful counter-example is the FFMpeg multimedia project, since several of its components are widely and consistently reused into other OSS projects. This paper documents the history of the libavcodec library of components from the FFMpeg project, which at present is reused in more than 140 OSS projects. Most of the recipients use it as a black-box component, although a number of OSS projects keep a copy of it in their repositories, and modify it as such. In both cases, we argue that libavcodec is a successful example of reusable OSS library of components.},
	keywords = {component-based software development, OSS components, Software reuse},
	author = {Capiluppi, Andrea and Boldyreff, Cornelia and Stol, Klaas-Jan}
}
@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 {Rigby:2011:UBB:1985793.1985867,
	title = {Understanding broadcast based peer review on open source software projects},
	booktitle = {Proceedings of the 33rd International Conference on Software Engineering},
	series = {ICSE {\textquoteright}11},
	year = {2011},
	note = {http://helium.cs.uvic.ca/other/Rigby2011ICSE.pdf

5 projects},
	pages = {541{\textendash}550},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {Software peer review has proven to be a successful technique in open source software (OSS) development. In contrast to industry, where reviews are typically assigned to specific individuals, changes are broadcast to hundreds of potentially interested stakeholders. Despite concerns that reviews may be ignored, or that discussions will deadlock because too many uninformed stakeholders are involved, we find that this approach works well in practice. In this paper, we describe an empirical study to investigate the mechanisms and behaviours that developers use to find code changes they are competent to review. We also explore how stakeholders interact with one another during the review process. We manually examine hundreds of reviews across five high profile OSS projects. Our findings provide insights into the simple, community-wide techniques that developers use to effectively manage large quantities of reviews. The themes that emerge from our study are enriched and validated by interviewing long-serving core developers.},
	keywords = {apache, case studies, email, freebsd, grounded theory, kde, linux, linux kernel, open source software, peer review, subversion},
	isbn = {978-1-4503-0445-0},
	doi = {10.1145/1985793.1985867},
	attachments = {https://flosshub.org/sites/flosshub.org/files/Rigby2011ICSE.pdf},
	author = {Peter C. Rigby and Storey, Margaret-Anne}
}
@proceedings {1293,
	title = {Virtual Health Information Infrastructures: A Scalable Regional Model},
	year = {2011},
	month = {10/2011},
	pages = {316-319},
	publisher = {Springer},
	abstract = {Integrating research, education and evidence-based medical practice requires complex infrastructures and network linkages among these critical activities. This research examines communities of practice and open source software tools in development of scalable virtual infrastructures for the regional Virtual Health Library of the Latin American and Caribbean Health Sciences System (Bireme) and embedded national cases. Virtual infrastructures refer to an environment characterized by overlapping distribution networks accessible through Internet portals and websites designed to facilitate integrated use of available resources. Case analysis shows engagement of interdisciplinary communities of practice for scalable virtual infrastructure design. This research program considers theory and methods for study of transferability of the Latin American model to large health care systems in other cultures.},
	keywords = {Bireme, Communities Of Practice, culture, open source systems, virtual infrastructures},
	author = {Seror, Ann}
}
@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}
}
@proceedings {1269,
	title = {What kind of commons is free software?},
	year = {2011},
	note = {Available under a CreativeCommons BY-NC-SA license (http://creativecommons.org/licenses/by-nc-sa/3.0/). The presentation slides are also attached; paper{\textquoteright}s LaTeX source files can be found at http://www.mediafire.com/?7k9dxbkna0x6irl},
	month = {06/2011},
	address = {Berlin, Germany},
	abstract = {This paper analyzes free software under the light of commons theories, and tries to answer whether it is a managed or open access commons. It briefly presents commons studies and its main concepts, as well as the discussion on immaterial commons, arguing that goods{\textquoteright} intrinsic characteristics should not be viewed as absolute, but rather contextualized in social struggles. Then, it proposes a two-tier structure for analyzing free software as a commons, considering its dual nature as source and machine code. The two connected layers of the proposal - use and development - are characterized according to commons theory categories; Android and software forking are explored as examples. It concludes that the first layer resembles an open access commons, but with intensional boundaries, and that the second one resembles multiple managed commons. This disparity is associated with the category of nested enterprises and with the layers{\textquoteright} relations to appropriation and production.},
	keywords = {commons, COMMUNITY, free software, governance},
	issn = {1613-0073},
	url = {http://ceur-ws.org/Vol-739/paper_10.pdf},
	attachments = {https://flosshub.org/sites/flosshub.org/files/VIEIRA.pdf , https://flosshub.org/sites/flosshub.org/files/VIEIRA_presentation_0.odp},
	author = {Vieira, Miguel Said}
}
@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 {1256,
	title = {Analyzing Leadership Dynamics in Distributed Group Communication},
	booktitle = {2010 43rd Hawaii International Conference on System Sciences (HICSS 2010)},
	year = {2010},
	note = {"Our analysis examines the communication patterns in two FLOSS development projects, Fire and Gaim"
"These data were imported into a database to allow automated analysis. The Fire data set includes about 1,800 events in the user email list, 7,800 messages in the developer venues, and 1,300 events in the combined trackers, spanning a period of 54 months. The significantly larger Gaim data set included over 41,000 events in the user forum, over 30,000 events in the developer venues, and about 20,000 events in the trackers, generated over 78 months."
"The dynamic network analysis was performed using a scientific workflow tool, Taverna Workbench"},
	pages = {1 - 10},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Honolulu, Hawaii, USA},
	abstract = {We apply social network analysis (SNA) to examine the dynamics of leadership in distributed groups, specifically Free/Libre Open Source Software development projects, and its relation to group performance. Based on prior work on leadership in distributed groups, we identify leaders with those who make the highest level of contribution to the group and assess the degree of leadership by measuring centralization of communications. We compare the dynamics of leadership in two FLOSS projects, one more and one less effective. We find that in both projects, centralization was higher in developer-oriented communications venues than in user-oriented venues, suggesting higher degrees of leadership in developer venues. However, we do not find a consistent relation between centralization and effectiveness. We suggest that SNA can instead be useful for identifying interesting periods in the history of the project, e.g., periods where the leadership of the project is in transition.},
	keywords = {core, DYNAMICS, email, email archives, fire, flossmole, gaim, leadership, mailing list, project success, social network analysis, srda},
	isbn = {978-1-4244-5509-6},
	doi = {10.1109/HICSS.2010.62},
	attachments = {https://flosshub.org/sites/flosshub.org/files/07-06-02.pdf},
	author = {Kevin Crowston and Andrea Wiggins and Howison, James}
}
@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 {954,
	title = {Clones: What is that smell?},
	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 = {72 - 81},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Cape Town, South Africa},
	abstract = {Clones are generally considered bad programming practice in software engineering folklore. They are identified as a bad smell and a major contributor to project maintenance difficulties. Clones inherently cause code bloat, thus increasing project size and maintenance costs. In this work, we try to validate the conventional wisdom empirically to see whether cloning makes code more defect prone. This paper analyses relationship between cloning and defect proneness. We find that, first, the great majority of bugs are not significantly associated with clones. Second, we find that clones may be less defect prone than non-cloned code. Finally, we find little evidence that clones with more copies are actually more error prone. Our findings do not support the claim that clones are really a "bad smell". Perhaps we can clone, and breathe easy, at the same time.},
	keywords = {apache, bug fix revisions, bugs, clone, evolution, gimp, nautilus, scm, source code},
	isbn = {978-1-4244-6802-7},
	doi = {10.1109/MSR.2010.5463343},
	attachments = {https://flosshub.org/sites/flosshub.org/files/72rahman2010cws.pdf},
	author = {Rahman, Foyzur and Christian Bird and Devanbu, Premkumar}
}
@conference {958,
	title = {Cloning and copying between GNOME projects},
	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 = {98 - 101},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Cape Town, South Africa},
	abstract = {This paper presents an approach to automatically distinguish the copied clone from the original in a pair of clones. It matches the line-by-line version information of a clone to the pair{\textquoteright}s other clone. A case study on the GNOME Desktop Suite revealed a complex flow of reused code between the different subprojects. In particular, it showed that the majority of larger clones (with a minimal size of 28 lines or higher) exist between the subprojects and more than 60\% of the clone pairs can be automatically separated into original and copy.},
	keywords = {clone, gnome, msr challenge, source code},
	isbn = {978-1-4244-6802-7},
	doi = {10.1109/MSR.2010.5463290},
	attachments = {https://flosshub.org/sites/flosshub.org/files/98Coning.pdf},
	author = {Krinke, Jens and Gold, Nicolas and Jia, Yue and Binkley, David}
}
@conference {960,
	title = {A comparative exploration of FreeBSD bug lifetimes},
	booktitle = {2010 7th IEEE Working Conference on Mining Software Repositories (MSR 2010)2010 7th IEEE Working Conference on Mining Software Repositories (MSR 2010)},
	year = {2010},
	pages = {106 - 109},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Cape Town, South Africa},
	abstract = {In this paper, we explore the viability of mining the basic data provided in bug repositories to predict bug lifetimes. We follow the method of Lucas D. Panjer as described in his paper, Predicting Eclipse Bug Lifetimes. However, in place of Eclipse data, the FreeBSD bug repository is used. We compare the predictive accuracy of five different classification algorithms applied to the two data sets. In addition, we propose future work on whether there is a more informative way of classifying bugs than is considered by current bug tracking systems.},
	keywords = {bug reports, bug tracking, classification, eclipse, msr challenge, prediction},
	isbn = {978-1-4244-6802-7},
	doi = {10.1109/MSR.2010.5463291},
	attachments = {https://flosshub.org/sites/flosshub.org/files/106ChallengeGargi.pdf},
	author = {Bougie, Gargi and Treude, Christoph and Daniel M. German and Storey, Margaret-Anne}
}
@conference {1258,
	title = {Exploring Complexity in Open Source Software: Evolutionary Patterns, Antecedents, and Outcomes},
	booktitle = {2010 43rd Hawaii International Conference on System Sciences (HICSS 2010)},
	year = {2010},
	note = {"The sample of projects was drawn from SourceForge"
"projects were selected that were built with C++."
"Applying the selection criteria generated a total of 108 projects for analysis"
"Scientific Toolwork{\textquoteright}s Understand (version 1.4)"},
	pages = {1 - 11},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Honolulu, Hawaii, USA},
	abstract = {Software complexity is important to researchers and managers, yet much is unknown about how complexity evolves over the life of a software application and whether different dimensions of software complexity may exhibit similar or different evolutionary patterns. Using cross-sectional and longitudinal data on a sample of 108 open source projects, this research investigated how the complexity of open source project releases varied throughout the life of the project. Functional data analysis was applied to the release histories of the projects and recurring evolutionary patterns were derived. There were projects that saw little evolution, according to their measures of size and structural complexity. However, projects that displayed some evolution often differed on the pattern of evolution depending on whether size or structural complexity was examined. Factors that contribute to and result from the patterns of complexity were evaluated, and implications for research and practice are presented.},
	keywords = {complexity, evolution, fda, life cycle, sourceforge, srda},
	isbn = {978-1-4244-5509-6},
	doi = {10.1109/HICSS.2010.198},
	attachments = {https://flosshub.org/sites/flosshub.org/files/10-07-02.pdf},
	author = {Darcy, David P. and Daniel, Sherae L. and Stewart, Katherine J.}
}
@conference {959,
	title = {Finding file clones in FreeBSD Ports Collection},
	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 = {102 - 105},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Cape Town, South Africa},
	abstract = {In Open Source System (OSS) development, software components are often imported and reused; for this reason we might expect that files are copied in multiple projects (file clones). In this paper, we propose a file clone detection tool called FCFinder and show the analysis performed with it on the FreeBSD Ports Collection, a large OSS project collection. We found many file clones among similar or related projects, which are systematically introduced from base projects.},
	keywords = {clone, freebsd, msr challenge, source code},
	isbn = {978-1-4244-6802-7},
	doi = {10.1109/MSR.2010.5463293},
	attachments = {https://flosshub.org/sites/flosshub.org/files/102FreeBSDClones.pdf},
	author = {Sasaki, Yusuke and Yamamoto, Tetsuo and Hayase, Yasuhiro and Inoue, Katsuro}
}
@conference {965,
	title = {Identifying licensing of jar archives using a code-search approach},
	booktitle = {2010 7th IEEE Working Conference on Mining Software Repositories (MSR 2010)2010 7th IEEE Working Conference on Mining Software Repositories (MSR 2010)},
	year = {2010},
	pages = {151 - 160},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Cape Town, South Africa},
	abstract = {Free and open source software strongly promotes the reuse of source code. Some open source Java components/libraries are distributed as jar archives only containing the bytecode and some additional information. For whoever wanting to integrate this jar in her own project, it is important to determine the license(s) of the code from which the jar archive was produced, as this affects the way that such component can be used. This paper proposes an automatic approach to determine the license of jar archives, combining the use of a code-search engine with the automatic classification of licenses contained in textual flies enclosed in the jar. Results of an empirical study performed on 37 jars - from 17 different systems - indicate that this approach is able to successfully infer the jar licenses in over 95\% of the cases, but that in many cases the license in textual flies may differ from the one of the classes contained in the jar.},
	keywords = {apache, bytecode, classification, eclipse, google code, jar, java, licenses, source code},
	isbn = {978-1-4244-6802-7},
	doi = {10.1109/MSR.2010.5463282},
	attachments = {https://flosshub.org/sites/flosshub.org/files/151msr2010.pdf},
	author = {Di Penta, Massimiliano and Daniel M. German and Antoniol, Giuliano}
}
@article {1240,
	title = {Impact of Programming Language Fragmentation on Developer Productivity},
	journal = {International Journal of Open Source Software and Processes},
	volume = {2},
	year = {2010},
	month = {32/2010},
	pages = {41 - 61},
	abstract = {Programmers often develop software in multiple languages. In an effort to study the effects of programming language fragmentation on productivity{\textemdash}and ultimately on a developer{\textquoteright}s problem-solving abilities{\textemdash}the authors present a metric, language entropy, for characterizing the distribution of a developer{\textquoteright}s programming efforts across multiple programming languages. This paper presents an observational study examining the project contributions of a random sample of 500 SourceForge developers. Using a random coefficients model, the authors find a statistically (alpha level of 0.001) and practically significant correlation between language entropy and the size of monthly project contributions. Results indicate that programming language fragmentation is negatively related to the total amount of code contributed by developers within SourceForge, an open source software (OSS) community.},
	keywords = {commits, entropy, language entropy, programming languages, sourceforge, srda},
	issn = {1942-3934},
	doi = {10.4018/jossp.2010040104},
	author = {Krein, Jonathan L. and MacLean, Alexander C. and Knutson, Charles D. and Delorey, Daniel P. and Eggett, Dennis L.}
}
@conference {1255,
	title = {{\textquoteright}Letting go of Control{\textquoteright} to Embrace Open Source: Implications for Company and Community},
	booktitle = {2010 43rd Hawaii International Conference on System Sciences (HICSS 2010)},
	year = {2010},
	pages = {1 - 10},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Honolulu, Hawaii, USA},
	abstract = {It is increasingly understood across the information technology and services sector that engagement with the open source software model can serve as a means for firms to capture intellectual energy, learn about productive software processes, access relevant technical skills, identify and recruit staff, as well as obtain valuable resources including code. This paper reports a study undertaken within two large global IT companies that have been actively involved with open source for more than ten years. The study involved over 30 semi-structured interviews with employees of the companies drawn from top, middle, and lower level management, and included active and experienced developer as well as open source community members. Our findings indicate how these companies have adapted their day-to-day management practices to take into account the need for flexibility and freedom expected by open source communities. This paper focuses on how they {\textquoteright}let go of control{\textquoteright} and what the implications of this are for both companies and the communities involved. Our data reveals a number of themes and in this paper we focus on three principal ones; issues of requirements, total cost of adoption, and alignment of open source engagement with long term company strategy.},
	keywords = {adoption, companies, interviews, organizations},
	isbn = {978-1-4244-5509-6},
	doi = {10.1109/HICSS.2010.1},
	attachments = {https://flosshub.org/sites/flosshub.org/files/07-06-01.pdf},
	author = {Maha Shaikh and Cornford, Tony}
}
@conference {1218,
	title = {A Longitudinal Study on Collaboration Networks and Decision to Participate in a FLOSS Community},
	booktitle = {5th Workshop on Public Data about Software Development (WoPDaSD 2010)},
	year = {2010},
	note = {"we chose as a case of study Epiphany, which is the default web browser of the GNOME graphical desktop environment"

"We collected all relevant data by parsing all the bug reports in GNOME Bugzilla repository relative to Epiphany. The data collection and storing was done using Bicho (v. 0.4 rev. 7198), a software part of the FLOSSMetric project [14]."},
	abstract = {In this paper we conjecture that individual decisions of FLOSS (Free/Libre Open Source Software) developers to take on a task are influenced by network relations generated by collaboration among project members. In order to explore our conjecture we collected data on a FLOSS project team consisting of 227 developers committed since 2002 to the development of a web browser. We reconstructed 2-mode co- collaboration networks (software developer by bug) in which a tie represents an action taken by a developer in order to solve a specific bug. Co-collaboration networks were collected at five points in time during a six-month development cycle of the software. We report and discuss results of longitudinal actor-based modeling that we specify to test for the influence of local network structures on developer{\textquoteright}s decision to take action on a specific bug. The study controls for bug-specific and developer-specific characteristics that may also affect developers{\textquoteright} decisions exogenously. We also control for priority and severity levels assigned by the team to bugs in an attempt to manage voluntary contribution.},
	keywords = {bicho, bug fixing, bug reports, bugzilla, COLLABORATION, developers, epiphany, flossmetrics, gnome, social network analysis},
	attachments = {https://flosshub.org/sites/flosshub.org/files/wopdasd002.pdf},
	author = {Guido Conaldi and Tonellato, Marco}
}
@conference {837,
	title = {Lurking? Cyclopaths? A Quantitative Lifecyle Analysis of User Behavior in a Geowiki},
	booktitle = {ACM Conference on Computer-Human Interaction (CHI)},
	year = {2010},
	month = {04/2010},
	publisher = {Association for Computing Machinery},
	organization = {Association for Computing Machinery},
	address = {Atlanta, GA},
	keywords = {content,, geographic, geowiki,, information,, lurking, open, volunteer, volunteered, Wiki,, work,},
	author = {Panciera, K. and Priedhorsky, R. and Erickson, T. and Terveen, L.}
}
@conference {Oezbek:2010:OCS:1833272.1833274,
	title = {The onion has cancer: some social network analysis visualizations of open source project communication},
	booktitle = {Proceedings of the 3rd International Workshop on Emerging Trends in Free/Libre/Open Source Software Research and Development (FLOSS {\textquoteright}10)},
	series = {FLOSS {\textquoteright}10},
	year = {2010},
	note = {paper d/l from www.inf.fu-berlin.de/~oezbek/pub/OezThiPre10-SNA.pdf

"We study the introduction of process innovations in Open Source projects [33] by manually extracting innovation episodes from arch- ives of mailing-lists and analyzing these episodes qualitatively by the Grounded Theory Method [38]."

"we took all messages from the mailing-list archives in 2007 of the projects we were studying, turned each participant into a node (unifying multi- ple e-mail addresses where needed [6]), and computed relationship strength between A and B as the number of e-mails that are a reply of B to a message from A or vice versa, according to the in-reply-to header of the e-mail."

Our data set covers 11 of the 13 projects (from 7 different do- mains, selected from mailing-list archive Gmane to build a diverse set of projects) for which we analyzed innovation episodes. They include three workflow applications (Bugzilla, Flyspray, Request Tracker), two desktop environments (Rox, Xfce), two design tools (ArgoUML, a UML CASE tool; gEDA, a set of electronic design automation tools), one bootloader (Grub), one hardware emulator (Bochs), one operating system (FreeDOS), and one database man- agement system (MonetDB).},
	pages = {5{\textendash}10},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {Background: People contribute to OSS projects in wildly different degrees, from reporting a single defect once and never coming back to spending many hours each workday on the project over several years - or anything in between. It is a common conception that these degrees of participation sort the participants into a number of similar groups which are layered like the peels of an onion: The onion model. Objective: We check whether this model of gradually different degrees of participation is valid with respect to the participation in OSS project mailing-list traffic. Methods: We perform social network analysis based on replies to mailing-list messages and use visualization to check the nature of three different groups of participants. Results: There appears to be a discontinuity with respect to core members: The degree to which very active core members (as opposed to less active co-developers) react to e-mails of senders from the project{\textquoteright}s periphery is significantly higher than would be expected from their level of activity in general. Limitations: The effect might be an artifact of the assumption that each mailing-list message can be treated the same. Conclusions: We conclude that core member status may be qualitatively (rather than just quantitatively) different and the transition of individual mailing-list participants towards ever higher participation is qualitatively discontinuous.},
	keywords = {argouml, Bochs, bugzilla, communication structure, Flyspray, gEDA, Grub, MonetDB, open source process, request tracker, Rox, social network analysis, Xfce},
	isbn = {978-1-60558-978-7},
	doi = {10.1145/1833272.1833274},
	url = {http://doi.acm.org/10.1145/1833272.1833274},
	attachments = {https://flosshub.org/sites/flosshub.org/files/OezThiPre10-SNA.pdf},
	author = {Oezbek, Christopher and Prechelt, Lutz and Thiel, Florian}
}
@conference {Hissam,
	title = {On Open and Collaborative Software Development in the DoD},
	booktitle = {Seventh Annual Acquisition Research Symposium, {NPS} Proceedings -},
	volume = {1},
	number = {1},
	year = {2010},
	month = {04/2010},
	pages = {219{\textendash}235},
	publisher = {Naval Postgraduate School},
	organization = {Naval Postgraduate School},
	address = {Monterey, California},
	abstract = {The US Department of Defense (specifically, but not limited to, the DoD CIO{\textquoteright}s Clarifying Guidance Regarding Open Source Software, DISA{\textquoteright}s launch of Forge.mil and OSD{\textquoteright}s Open Technology Development Roadmap Plan) has called for increased use of open source software and the adoption of best practices from the free/open source software (F/OSS) community to foster greater reuse and innovation between programs in the DoD. In our paper, we examine some key aspects of open and collaborative software development inspired by the success of the F/OSS movement as it might manifest itself within the US DoD. This examination is made from two perspectives: the reuse potential among DoD programs sharing software and the incentives, strategies and policies that will be required to foster a culture of collaboration needed to achieve the benefits indicative of F/OSS. Our conclusion is that to achieve predictable and expected reuse, not only are technical infrastructures needed, but also a shift to the business practices in the software development and delivery pattern seen in the traditional acquisition lifecycle is needed. Thus, there is potential to overcome the challenges discussed within this paper to engender a culture of openness and community collaboration to support the DoD mission.},
	keywords = {collaborative development, open source software, reuse, software engineering},
	url = {http://www.acquisitionresearch.net/cms/_files/FY2010/NPS-AM-10-037.pdf},
	author = {Hissam, S. A. and Weinstock, C. and Bass, L.}
}
@conference {966,
	title = {Replaying IDE interactions to evaluate and improve change prediction approaches},
	booktitle = {2010 7th IEEE Working Conference on Mining Software Repositories (MSR 2010)2010 7th IEEE Working Conference on Mining Software Repositories (MSR 2010)},
	year = {2010},
	pages = {161 - 170},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Cape Town, South Africa},
	abstract = {Change prediction helps developers by recommending program entities that will have to be changed alongside the entities currently being changed. To evaluate their accuracy, current change prediction approaches use data from versioning systems such as CVS or SVN. These data sources provide a coarse-grained view of the development history that flattens the sequence of changes in a single commit. They are thus not a valid basis for evaluation in the case of development-style prediction, where the order of the predictions has to match the order of the changes a developer makes. We propose a benchmark for the evaluation of change prediction approaches based on fine-grained change data recorded from IDE usage. Moreover, the change prediction approaches themselves can use the more accurate data to fine-tune their prediction. We present an evaluation procedure and use it on several change prediction approaches, both novel and from the literature, and report on the results.},
	keywords = {cbse, change based software evolution, change prediction, changes, commit, cvs, development history, eclipseeye, ide, mylyn, spyware, svn},
	isbn = {978-1-4244-6802-7},
	doi = {10.1109/MSR.2010.5463278},
	attachments = {https://flosshub.org/sites/flosshub.org/files/161Robbes2010changePrediction.pdf},
	author = {Robbes, Romain and Pollet, Damien and Lanza, Michele}
}
@conference {967,
	title = {Should I contribute to this discussion?},
	booktitle = {2010 7th IEEE Working Conference on Mining Software Repositories (MSR 2010)},
	year = {2010},
	pages = {181 - 190},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Cape Town},
	abstract = {Development mailing lists play a central role in facilitating communication in open source projects. Since these lists frequently host design and project discussions, knowledgeable contribution to these discussion threads is essential to avoid mis-communication that might slow-down the progress of a project. However, given the sheer volume of emails on these lists, it is easy to miss important discussions. To find out how developers are able to deal with mailing list discussions, we study the main factors that encourage developers to contribute to the development mailing lists. We develop personalized models to automatically identify discussion threads that a developer would contribute to based on his previous contribution behavior. Case studies on development mailing lists of three open source projects (Apache, PostgreSQL and Python) show that the average accuracy of our models is 89-85\% and that the models vary significantly between different developers.},
	keywords = {apache, contributions, developers, email, email archives, mailing lists, postgresql, python},
	isbn = {978-1-4244-6802-7},
	doi = {10.1109/MSR.2010.5463345},
	attachments = {https://flosshub.org/sites/flosshub.org/files/181ibrahim-msr2010.pdf},
	author = {Ibrahim, Walid M and Bettenburg, Nicolas and Shihab, Emad and Adams, Bram and Hassan, Ahmed E.}
}
@article {Singh:2010:SEI:1824760.1824763,
	title = {The small-world effect: The influence of macro-level properties of developer collaboration networks on open-source project success},
	journal = {ACM Trans. Softw. Eng. Methodol.},
	volume = {20},
	number = {2},
	year = {2010},
	pages = {6:1{\textendash}6:27},
	publisher = {ACM},
	address = {New York, NY, USA},
	abstract = {In this study we investigate the impact of community-level networks{\textemdash}relationships that exist among developers in an OSS community{\textemdash}on the productivity of member developers. Specifically, we argue that OSS community networks characterized by small-world properties would positively influence the productivity of the member developers by providing them with speedy and reliable access to more quantity and variety of information and knowledge resources. Specific hypotheses are developed and tested using longitudinal data on a large panel of 4,279 projects from 15 different OSS communities hosted at Sourceforge. Our results suggest that significant variation exists in small-world properties of OSS communities at Sourceforge. After accounting for project, foundry, and time-specific observed and unobserved effects, we found a statistically significant relationship between small-world properties of a community and the technical and commercial success of the software produced by its members. In contrast to the findings of prior research, we also found the lack of a significant relationship between closeness and betweenness centralities of the project teams and their success. These results were robust to a number of controls and model specifications.},
	keywords = {collaborative software development, online community, open source software development, productivity, small world networks, social networks, sourceforge, team formation},
	issn = {1049-331X},
	doi = {10.1145/1824760.1824763},
	url = {http://doi.acm.org/10.1145/1824760.1824763},
	author = {Param Vir Singh}
}
@article {1376,
	title = {Sustainability of Open-Source Projects: A Longitudinal Study},
	journal = {Journal of the Association for Information Systems},
	volume = {11},
	number = {5},
	year = {2010},
	abstract = {This paper examines the factors that influence the long-term sustainability of FLOSS projects. A model of project sustainability based on organizational ecology is developed and tested empirically. Data about activity and contribution patterns over the course of five years for 2,772 projects registered with SourceForge is analyzed. Our results suggest that the size of the project{\textquoteright}s development base, project age and the size of niche occupied by the project are positively related to the project{\textquoteright}s ability to attract user and/or developer resources. The ability to attract resources is an indicator of the perceived project legitimacy, which in turn is a strong predictor of the project{\textquoteright}s future sustainability. Thus a project{\textquoteright}s ability to attract developer and user resources is shown to play a mediating role between the demographic (size and age) and ecological (niche) characteristics of the project and its future sustainability. Our results support the applicability of tenets of organizational ecology related to the liability of smallness, the liability of newness, and population characteristics (niche size) to the FLOSS development environment. The implications of the results for future research and practice are discussed.},
	keywords = {contribution, developers, sourceforge, sustainability},
	url = {http://aisel.aisnet.org/jais/vol11/iss11/5/},
	author = {Chengular-Smith, I. and Sidorova, Anna and Daniel, Sherae L.}
}
@conference {1259,
	title = {Towards an Openness Rating System for Open Source Software},
	booktitle = {2010 43rd Hawaii International Conference on System Sciences (HICSS 2010)},
	year = {2010},
	pages = {1 - 8},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Honolulu, Hawaii, USA},
	abstract = {Many open source software projects are not very open to third party developers. The point of open source is to enable anyone to fix bugs or add desired capabilities without holding them hostage to the original developers. This principle is important because an open source project{\textquoteright}s developers may be unresponsive or unable to meet third party needs, even if funding support for requested improvements is offered.This paper presents a simple rating system for evaluating the openness of software distributions. The rating system considers factors such as platform portability, documentation, licensing, and contribution policy. Several popular open source products are rated in order to illustrate the efficacy of the rating system.},
	keywords = {alice, case study, contribution, documentation, freespire, galib, latex, license, linux, linux kernel, mediaportal, openness, openoffice, opensolaris, rating, unicon},
	isbn = {978-1-4244-5509-6},
	doi = {10.1109/HICSS.2010.405},
	attachments = {https://flosshub.org/sites/flosshub.org/files/10-07-04.pdf},
	author = {Bein, Wolfgang and Jeffery, Clinton}
}
@conference {1217,
	title = {Trends That Affect Temporal Analysis Using SourceForge Data},
	booktitle = {5th Workshop on Public Data about Software Development (WoPDaSD 2010)},
	year = {2010},
	note = {"In this paper we examine some of the limitations of artifact data by specifically addressing the applicability of SourceForge data to the study of project evolution."

"For our analysis we examine 9,997 Production/Stable or Maintenance phase projects stored in CVS on SourceForge and extracted in October of 2006 [5]"},
	abstract = {SourceForge is a valuable source of software artifact data for researchers who study project evolution and developer behavior. However, the data exhibit patterns that may bias temporal analyses. Most notable are cliff walls in project source code repository timelines, which indicate large commits that are out of character for the given project. These cliff walls often hide significant periods of development and developer collaboration{\textemdash}a threat to studies that rely on SourceForge repository data. We demonstrate how to identify these cliff walls, discuss reasons for their appearance, and propose preliminary measures for mitigating their effects in evolution-oriented studies.},
	keywords = {cliff walls, committers, cvs, evolution, growth, source code, sourceforge, time, time series},
	attachments = {https://flosshub.org/sites/flosshub.org/files/wopdasd001.pdf},
	author = {MacLean, Alexander C. and Pratt, Landon J. and Krein, Jonathan L. and Knutson, Charles D.}
}
@book {1250,
	title = {Warehousing and Studying Open Source Versioning Metadata},
	series = {IFIP Advances in Information and Communication Technology Open Source Software: New Horizons (OSS 2010)},
	volume = {319},
	year = {2010},
	pages = {413 - 418},
	publisher = {Springer Berlin Heidelberg},
	organization = {Springer Berlin Heidelberg},
	address = {Berlin, Heidelberg},
	abstract = {In this paper, we describe the downloading and warehousing of Open Source Software (OSS) versioning metadata from SourceForge, BerliOS Developer, and GNU Savannah. This data enables and supports research in areas such as software engineering, open source phenomena, social network analysis, data mining, and project management. This newly-formed database containing Concurrent Versions System (CVS) and Subversion (SVN) metadata offers new research opportunities for large-scale OSS development analysis. The CVS and SVN data is juxtaposed with the SourceForge.net Research Data Archive [5] for the purpose of performing more powerful and interesting queries. We also present an initial statistical analysis of some of the most active projects. },
	keywords = {berlios, cvs, savannah, scm, sourceforge, srda, subversion, svn},
	isbn = {978-3-642-13244-5},
	issn = {1861-2288},
	doi = {10.1007/978-3-642-13244-5_40},
	author = {van Antwerp, M. and Madey, G.},
	editor = {{\r A}gerfalk, P{\"a}r and Boldyreff, Cornelia and Gonz{\'a}lez-Barahona, Jes{\'u}s M. and Madey, Gregory R. and Noll, John}
}
@conference {839,
	title = {Amassing and indexing a large sample of version control systems: towards the census of public source code history},
	booktitle = {6th IEEE Working Conference on Mining Software Repositories},
	year = {2009},
	note = {Related work: "For example, FLOSSMole [8]
collects the list of projects and their metadata from SourceForge,
FreshMeat, Free Software Foundation (FSF), RubyForge,
and ObjectWeb. "

"The list of
home pages from open source directories such as FSF or
FLOSSMole could provide a focused set of web pages for
the search"

"To get the list of projects for SourceForge we used
FLOSSMole project [8] that collects the list of SourceForge
projects and their metadata. We use project ID, because it
was used to specify the VCS URL within the SourceForge
repository."},
	month = {May 16{\textendash}17},
	abstract = {The source code and its history represent the output and process of software development activities and are an in- valuable resource for study and improvement of software development practice. While individual projects and groups of projects have been extensively analyzed, some fundamental questions, such as the spread of innovation or genealogy of the source code, can be answered only by considering the entire universe of publicly available source code and its history. We describe methods we developed over the last six years to gather, index, and update an approximation of such a universal repository for publicly accessible version control systems and for the source code inside a large corporation. While challenging, the task is achievable with limited resources. The bottlenecks in network bandwidth, processing, and disk access can be dealt with using inherent parallelism of the tasks and suitable tradeoffs between the amount of storage and computations, but a completely automated discovery of public version control systems may require enticing participation of the sampled projects. Such universal repository would allow studies of global properties and origins of the source code that are not possible through other means.},
	keywords = {bazaar, cvs, flossmole, git, mercurial, source code, sourceforge, subversion, version control},
	attachments = {https://flosshub.org/sites/flosshub.org/files/11amassing.pdf},
	author = {Audris Mockus}
}
@conference {930,
	title = {Author entropy vs. file size in the GNOME suite of applications},
	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 = {91 - 94},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Vancouver, BC, Canada},
	abstract = {We present the results of a study in which author entropy was used to characterize author contributions per file. Our analysis reveals three patterns: banding in the data, uneven distribution of data across bands, and file size dependent distributions within bands. Our results suggest that when two authors contribute to a file, large files are more likely to have a dominant author than smaller files.},
	keywords = {author entropy, contributions, gnome, msr challenge},
	isbn = {978-1-4244-3493-0},
	doi = {10.1109/MSR.2009.5069484},
	author = {Casebolt, Jason R. and Krein, Jonathan L. and MacLean, Alexander C. and Knutson, Charles D. and Delorey, Daniel P.}
}
@conference {1264,
	title = {The Commit Size Distribution of Open Source Software},
	booktitle = {2009 42nd Hawaii International Conference on System Sciences (HICSS 2009)},
	year = {2009},
	note = {"We use the database of the open source analytics firm Ohloh Inc."
"This article is based on a March 2008 database snapshot, which contains 9,363 completely crawled and analyzed projects covering a time frame from January 1990 to February 2008."
"The Ohloh database provides the complete configuration management history of each crawled project (to the extent available on the web). Thus, every single commit action of all the projects over their entire history is available."
"We measure the size of commits in this paper in source lines of code (SLoC) using Ohloh{\textquoteright}s own open source diff too"},
	pages = {1 - 8},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Waikoloa, Hawaii, USA},
	abstract = {With the growing economic importance of open source, we need to improve our understanding of how open source software development processes work. The analysis of code contributions to open source projects is an important part of such research. In this paper we analyze the size of code contributions to more than 9,000 open source projects. We review the total distribution and distinguish three categories of code contributions using a size-based heuristic: single focused commits, aggregate team contributions, and repository refactorings. We find that both the overall distribution and the individual categories follow a power law. We also suggest that distinguishing these commit categories by size will benefit future analyses.},
	keywords = {commits, configuration management, history, lines of code, sloc, source code},
	isbn = {978-0-7695-3450-3},
	doi = {10.1109/HICSS.2009.421},
	attachments = {https://flosshub.org/sites/flosshub.org/files/07-07-07.pdf},
	author = {Arafat, O. and Dirk Riehle}
}
@conference {1244,
	title = {Design Information Sharing Across Multiple Knowledge Systems in a FLOSS Community},
	booktitle = {iConference {\textquoteright}09},
	year = {2009},
	month = {02/2009},
	abstract = {This paper explores support for design information sharing between the distinct knowledge systems and skill sets of interactive system designers and developers. The paper focuses on the challenges of sharing information among groups of designers, developers, and users with multiple knowledge systems in the context of free/libre/open source software (FLOSS) communities. Bringing design to FLOSS communities introduces new knowledge into a solitary community of practice, and discussion ensues about how exploiting the {\textquoteright}symmetry of ignorance{\textquoteright} can enhance information sharing through design in CodePlex, an open source project hosting community website. Finally, design mockups illustrate how CodePlex serves as a boundary object supporting design information sharing across distinct knowledge systems.},
	keywords = {codeplex, developers, information sharing},
	attachments = {https://flosshub.org/sites/flosshub.org/files/finalDraft41.pdf},
	author = {Bach, Paula}
}
@article {Subramaniam:2009:DOS:1480545.1480824,
	title = {Determinants of open source software project success: A longitudinal study},
	journal = {Decis. Support Syst.},
	volume = {46},
	year = {2009},
	month = {January},
	pages = {576{\textendash}585},
	publisher = {Elsevier Science Publishers B. V.},
	address = {Amsterdam, The Netherlands, The Netherlands},
	abstract = {In this paper, we investigate open source software (OSS) success using longitudinal data on OSS projects. We find that restrictive OSS licenses have an adverse impact on OSS success. On further analysis, restrictive OSS license is found to be negatively associated with developer interest, but is positively associated with the interest of non-developer users and project administrators. We also show that developer and non-developer interest in the OSS project and the project activity levels in any time period significantly affect the project success measures in subsequent time period. The implications of our findings for OSS research and practice are discussed. },
	keywords = {contributors, developers, licenses, longitudinal study, Open source project, OSS, project success, restrictive, Software project success},
	issn = {0167-9236},
	doi = {10.1016/j.dss.2008.10.005},
	url = {http://portal.acm.org/citation.cfm?id=1480545.1480824},
	author = {Subramaniam, Chandrasekar and Sen, Ravi and Nelson, Matthew L.}
}
@article {10.1109/HICSS.2009.713,
	title = {Evaluating Longitudinal Success of Open Source Software Projects: A Social Network Perspective},
	journal = {2009 42nd Hawaii International Conference on System Sciences (HICSS 2009)},
	year = {2009},
	note = {"We collect data of various OSS projects over an extended period of 13 months and utilize cross-sectional time-series panel data analysis methods..."
"we observe and analyze the developers{\textquoteright} interactions through bug, patch, support request, and feature request (BPSF) tracking systems hosted on SourceForge.net"
"Three criteria are adopted to select useful projects: projects are selected from top 7000 ranked projects; projects have at least three developers; and there are enough interactions to ensure that each sociomatrix is equal to or larger than 3{\texttimes}3 matrix..."},
	pages = {1-10},
	publisher = {IEEE Computer Society},
	address = {Los Alamitos, CA, USA},
	abstract = {To date, numerous open source projects are hosted on many online repositories. While some of these projects are active and thriving, some projects are either languishing or showing no development activities at all. This phenomenon thus begs the important question of what are the influential factors that affect the success of open source projects. In a quest to deepen our understanding of the evolution of open source projects, this research aims to analyze the success of open source projects by using the theoretical lens of social network analysis. Based on extensive analyses of data collected from online repositories, we study the impact of the communication patterns of software development teams on the demand and supply outcomes of these projects, while accounting for project-specific characteristics. Using panel data analysis of data over 13 months, we find significant impacts of communication patterns on project outcomes over the long term.},
	keywords = {bug tracking system, communication, project success, social network analysis, sourceforge},
	isbn = {978-0-7695-3450-3},
	doi = {http://doi.ieeecomputersociety.org/10.1109/HICSS.2009.713},
	attachments = {https://flosshub.org/sites/flosshub.org/files/09-02-12.pdf},
	author = {Jing Wu and Khim Yong Goh}
}
@conference {931,
	title = {Evaluating process quality in GNOME based on change request data},
	booktitle = {2009 6th IEEE International Working Conference on Mining Software Repositories (MSR)2009 6th IEEE International Working Conference on Mining Software Repositories},
	year = {2009},
	pages = {95 - 98},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Vancouver, BC, Canada},
	abstract = {The lifecycle of defects reports and enhancement requests collected in the Bugzilla database of the GNOME project provides valuable information on the evolution of the change request process and for the assessment of process quality in the GNOME sub projects. We present a quality model for the analysis of quality characteristics that is based on evaluating metrics on the Bugzilla database, and illustrate it with a comparative evaluation for 25 of the largest products within GNOME.},
	keywords = {bugzilla, bugzillametrics.org, change analysis, change history, gnome, msr challenge, qmetric},
	isbn = {978-1-4244-3493-0},
	doi = {10.1109/MSR.2009.5069485},
	attachments = {https://flosshub.org/sites/flosshub.org/files/95ProcessQualityInGNOME.pdf},
	author = {Schackmann, Holger and Lichter, Horst}
}
@conference {941,
	title = {Evolution of the core team of developers in libre software projects},
	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 = {167 - 170},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Vancouver, BC, Canada},
	abstract = {In many libre (free, open source) software projects, most of the development is performed by a relatively small number of persons, the "core team". The stability and permanence of this group of most active developers is of great importance for the evolution and sustainability of the project. In this position paper we propose a quantitative methodology to study the evolution of core teams by analyzing information from source code management repositories. The most active developers in different periods are identified, and their activity is calculated over time, looking for core team evolution patterns.},
	keywords = {core, cvs, cvsanaly, developers, evolution, gimp, scm},
	isbn = {978-1-4244-3493-0},
	doi = {10.1109/MSR.2009.5069497},
	attachments = {https://flosshub.org/sites/flosshub.org/files/167core-evolution.pdf},
	author = {Gregorio Robles and Jesus M. Gonzalez-Barahona and Herraiz, Israel}
}
@conference {1203,
	title = {Flat for the few, steep for the many: Structural cohesion as  a measure of hierarchy in FLOSS communities},
	booktitle = {4th Workshop on Public Data about Software Development (WoPDaSD 2009)},
	year = {2009},
	note = {"The FLOSS project selected as case study is the GNOME web browser Epiphany. The communication network was  generated tracing backwards mail threads in the development mailing list. "},
	month = {2009},
	abstract = {A discrepancy exists between the emphasis posed by practitioners on decentralized and non-hierarchical communication in Free/Libre Open Source Software (FLOSS) communities and empirical evidence of their hierarchical structure. In order to explain this apparent paradox it is here hypothesized that in FLOSS communities local sub-groups exist and are less hierarchical, more decentralized than the whole social network to which they belong. A measure of structural cohesion based on network node connectivity is proposed as an effective method to test whether FLOSS communication networks can be decomposed in nested hierarchies of progressively less centralized sub-groups. Preliminary results from a case study that are consistent with the hypothesis are presented and discussed. },
	keywords = {case study, email, email archives, epiphany, gnome, mailing list, social network analysis},
	attachments = {https://flosshub.org/sites/flosshub.org/files/guido-conaldi-flat-for-the-few.pdf},
	author = {Guido Conaldi}
}
@conference {1204,
	title = {Language entropy: A metric for characterization of author programming language distribution},
	booktitle = {4th Workshop on Public Data about Software Development (WoPDaSD 2009)},
	year = {2009},
	note = {The data set used in this study was previously collected for a separate, but related work. It was originally extracted from the SourceForge Research Archive (SFRA), August 2006. For a detailed discussion of the data source, collection tools and processes, and summary statistics, see [6]."

"From the initial data set we extracted a random sample of 500 developers3 along with descriptive details of all revisions that those developers made since the inception of the projects on which they worked. We then condensed this sample by totaling the lines of code added by each developer for each month in which that developer made at least one code submission."
[6] Daniel P. Delorey, Charles D. Knutson, and Alex MacLean. Studying production phase sourceforge projects: A case study using cvs2mysql and sfra+. In Second International Workshop on Public Data about Software Development (WoPDaSD {\textquoteright}07), June 2007.},
	month = {2009},
	abstract = {Programmers are often required to develop in multiple languages. In an effort to study the effects of programming language fragmentation on productivity{\textemdash}and ultimately on a programmer{\textquoteright}s problem solving abilities{\textemdash}we propose a metric, language entropy, for characterizing the distribution of an individual{\textquoteright}s development efforts across multiple programming languages. To evaluate this metric, we present an observational study examining all project contributions (through August 2006) of a random sample of 500 SourceForge developers. Using a random coefficients model, we found a statistically significant correlation (alpha level of 0.05) between language entropy and the size of monthly pro ject contributions (measured in lines of code added). Our results indicate that language entropy is a good candidate for characterizing author programing language distribution.},
	keywords = {contributions, developers, language entropy, lines of code, loc, multiple languages, programming languages, sourceforge},
	attachments = {https://flosshub.org/sites/flosshub.org/files/LanguageEntropy-JonathanKrein.pdf},
	author = {Krein, Jonathan L. and MacLean, Alexander C. and Delorey, Daniel P. and Knutson, Charles D. and Eggett, Dennis L.}
}
@conference {944,
	title = {Learning from defect removals},
	booktitle = {2009 6th IEEE International Working Conference on Mining Software Repositories (MSR)2009 6th IEEE International Working Conference on Mining Software Repositories},
	year = {2009},
	pages = {179 - 182},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Vancouver, BC, Canada},
	abstract = {Recent research has tried to identify changes in source code repositories that fix bugs by linking these changes to reports in issue tracking systems. These changes have been traced back to the point in time when they were previously modified as a way of identifying bug introducing changes. But we observe that not all changes linked to bug tracking systems are fixing bugs; some are enhancing the code. Furthermore, not all fixes are applied at the point in the code where the bug was originally introduced. We flesh out these observations with a manual review of several software projects, and use this opportunity to see how many defects are in the scope of static analysis tools.},
	keywords = {bug fixing, bugzilla, change management, cherry, cvs, eclipse, groovy, launching, source code, svn, text editor},
	isbn = {978-1-4244-3493-0},
	doi = {10.1109/MSR.2009.5069500},
	attachments = {https://flosshub.org/sites/flosshub.org/files/179LearnFromDefects-MSR09.pdf},
	author = {Ayewah, Nathaniel and Pugh, William}
}
@article {1118,
	title = {Monetary donations to an open source software platform},
	journal = {Research Policy},
	volume = {38},
	year = {2009},
	month = {03/2009},
	pages = {404 - 414},
	abstract = {Online open source software platforms, such as Sourceforge.net, play a vital role in creating an ecosystem that enables the creation and growth of open source projects. However, there is little research exploring the interactions between open source stakeholders and the platform. We believe that the sustainability of the platform crucially depends on financial incentives. While platforms can obtain these incentives through multiple means, in this paper we focus on one form of financial incentives{\textemdash}voluntary monetary donations by open source community members. We report findings from two empirical studies that examine factors that impact donations. Study 1 investigates the factors that cause some community members to donate and not others. We find that the decision to donate is impacted by relational commitment with open source software platform, donation to projects and accepting donations from others. Study 2 examines what drives the level of donation. We find that the length of association with the platform and relational commitment affects donation levels.},
	keywords = {Collective action, Donation, Identification, incentives, metadata, MOTIVATION, Open source software platform, projects, Reciprocity, Relational commitment, sourceforge},
	issn = {00487333},
	doi = {10.1016/j.respol.2008.11.004},
	author = {Sandeep Krishnamurthy and Tripathi, Arvind K.}
}
@conference {1263,
	title = {Multiple Social Networks Analysis of FLOSS Projects using Sargas},
	booktitle = {2009 42nd Hawaii International Conference on System Sciences (HICSS 2009)},
	year = {2009},
	note = {"The interval of analysis for the first three networks was from 2003/02/24 to 2003/11/03. These networks were created using the OSSNetwork tool [18]. The source code of the PMD project was collected starting on 2002/06/24..."
"Transflow performs a co-changes analysis of the source code modification history and creates a matrix where software components are connected by taking into account the frequency that they have been changed together (i.e., in the same check-in): if two files have been changed together in the same check-in, an edge is created to link these two files."},
	pages = {1 - 10},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Waikoloa, Hawaii, USA},
	abstract = {Due to their characteristics and claimed advantages, several researchers have been investigating free and open-source projects. Different aspects are being studied: for instance, what motivates developers to join FLOSS projects, the tools, processes and practices used in FLOSS projects, the evolution of FLOSS communities among other things. Researchers have studied collaboration and coordination of open source software developers using an approach known as social network analysis and have gained important insights about these projects. Most researchers, however, have not focused on the integrated study of these networks and, accordingly, in their interrelationships. This paper describes an approach and tool to combine multiple social networks to study the evolution of open-source projects. Our tool, named Sargas, allows comparison and visualization of different social networks at the same time. Initial results of our analysis can be used to extend the "onion-model" of open source participation.},
	keywords = {case study, multiple social networks, ossnetwork, pmd, social network analysis, transflow},
	isbn = {978-0-7695-3450-3},
	doi = {10.1109/HICSS.2009.316},
	attachments = {https://flosshub.org/sites/flosshub.org/files/07-07-06.pdf},
	author = {de Sousa, S.F. and Balieiro, M.A. and dos R. Costa, J.M. and de Souza, C.R.B.}
}
@article {Capiluppi200989,
	title = {Quality Factors and Coding Standards - a Comparison Between Open Source Forges},
	journal = {Electronic Notes in Theoretical Computer Science},
	volume = {233},
	year = {2009},
	note = {Proceedings of the International Workshop on Software Quality and Maintainability (SQM 2008)},
	pages = {89 - 103},
	abstract = {Enforcing adherence to standards in software development in order to produce high quality software artefacts has long been recognised as best practice in traditional software engineering. In a distributed heterogeneous development environment such those found within the Open Source paradigm, coding standards are informally shared and adhered to by communities of loosely coupled developers. Following these standards could potentially lead to higher quality software. This paper reports on the empirical analysis of two major forges where OSS projects are hosted. The first one, the KDE forge, provides a set of guidelines and coding standards in the form of a coding style that developers may conform to when producing the code source artefacts. The second studied forge, SourceForge, imposes no formal coding standards on developers. A sample of projects from these two forges has been analysed to detect whether the SourceForge sample, where no coding standards are reinforced, has a lower quality than the sample from KDE. Results from this analysis form a complex picture; visually, all the selected metrics show a clear divide between the two forges, but from the statistical standpoint, clear distinctions cannot be drawn amongst these quality related measures in the two forge samples.},
	keywords = {artefacts, artifacts, coding standards, coding style, complexity, forge, forges, kde, metrics, quality, source code, sourceforge},
	issn = {1571-0661},
	doi = {DOI: 10.1016/j.entcs.2009.02.063},
	url = {http://www.sciencedirect.com/science/article/B75H1-4VXDKRV-7/2/abcc2be2c4c3998e4bc9b53473ca2d81},
	author = {Capiluppi, Andrea and Boldyreff, Cornelia and Karl Beecher and Paul J. Adams}
}
@article {1082,
	title = {Returns from social capital in open source software networks},
	journal = {Journal of Evolutionary Economics},
	volume = {19},
	year = {2009},
	note = {"The data we use in this analysis come from the SourceForge.net Research Data (Department of Computer Science and Engineering, University of Notre Dame)." "Particularly, our dataset is a sub-sample of 2,962 valid observations over twelve months of projects aimed at developing games{\textquoteright} software. To get this sample, we look at the monthly dumps of data and select all projects that belong to the category of GNU Public License (GPL) [6]. "
dependent variable: performance (number of downloads); independent variable: social network ("Here we measure ties among projects through the individuals{\textquoteright} member and contributor roles at projects on the network over time.)},
	month = {4/2009},
	pages = {277 - 295},
	abstract = {Open Source Software projects base their operation on a collaborative structure for knowledge exchange in the form of provision or reception of information, expertise, and feedback on the creation of source code. Here, we address the direction of these knowledge flows among projects throughout social networks and their impact on project success. We identify the roles of membership or contribution that individuals play within projects. We found that connections through contributors who bring their knowledge to the project, improve project success, and that connection through members, who transfer their knowledge towards other projects, enhance project success. Finally, we found that ties through shared membership and contributions hamper project success. The analysis of knowledge flows and their impact on project success imply a translation of returns from investment in social capital, where investment takes the shape of knowledge flows and the returns mean the projects{\textquoteright} diffusion over the network.},
	keywords = {contributors, developers, games, gpl, project success, roles, social capital, social network analysis, social networks, sourceforge, srda, teams},
	issn = {1432-1386},
	doi = {10.1007/s00191-008-0125-5},
	attachments = {https://flosshub.org/sites/flosshub.org/files/Mendez-DuronGarcia.pdf},
	author = {M{\'e}ndez-Dur{\'o}n, Rebeca and Garc{\'\i}a, Clara E.}
}
@article {schryen2009security,
	title = {Security of Open Source and Closed Source Software: An Empirical Comparison of Published Vulnerabilities},
	journal = {AMCIS 2009 Proceedings},
	year = {2009},
	pages = {387},
	abstract = {Reviewing literature on open source and closed source security reveals that the discussion is often determined by biased attitudes toward one of these development styles. The discussion specifically lacks appropriate metrics, methodology and hard data. This paper contributes to solving this problem by analyzing and comparing published vulnerabilities of eight open source software and nine closed source software packages, all of which are widely deployed. Thereby, it provides an extensive empirical analysis of vulnerabilities in terms of mean time between vulnerability disclosures, the development of disclosure over time, and the severity of vulnerabilities, and allows for validating models provided in the literature. The investigation reveals that (a) the mean time between vulnerability disclosures was lower for open source software in half of the cases, while the other cases show no differences, (b) in contrast to literature assumption, 14 out of 17 software packages showed a significant linear or piecewise linear correlation between time and the number of published vulnerabilities, and (c) regarding the severity of vulnerabilities, no significant differences were found between open source and closed source.},
	keywords = {closed source software, empirical comparison, open source software, security, Vulnerabilities},
	url = {http://epub.uni-regensburg.de/21296/1/Schryen_-_AMCIS_09_-_Security_of_open_source_and_closed_source_software_-_Web_version.pdf},
	attachments = {https://flosshub.org/sites/flosshub.org/files/Schryen_-_AMCIS_09_-_Security_of_open_source_and_closed_source_software_-_Web_version.pdf},
	author = {Schryen, Guido}
}
@mastersthesis {1243,
	title = {Supporting the user experience in free/libre/open source software development},
	year = {2009},
	abstract = {With the increasing number and awareness of free/libre/open source software (FLOSS) projects, Internet users can download a FLOSS tool that meets just about any need. The user experience of projects, however, varies greatly and identifying FLOSS projects that offer a positive user experience (UX) is challenging. FLOSS projects center on software developer activities with little attention to user-centered design activities that could increase the user experience on the project. The purpose of this dissertation is to understand open source software ecology in order to bring support for user experience design activities on FLOSS projects. CodePlex, an open source project hosting website, serves as the open source software ecology.

The research consists of two phases, a descriptive science phase and a design science phase. In the descriptive phase fieldwork in the form of ethnomethodologically informed ethnography describes the everyday activities of three groups: the team that produces CodePlex, the participants who use CodePlex to produce open source projects, and user experience practitioners who bring their expertise to design software with a positive user experience. The descriptive phase also includes an analysis of activity awareness of the three groups. The design science phase consists of a claims analysis that provides design rationale for a design that proposes to support UX activities on CodePlex. The results show that activity awareness contributes to the socio-technical solution where UX activities can be supported as a new community of practice, with features that support building social capital. The UX support features include a UX workspace where UX contributors recognize their value and other features that support the presence of UX throughout the project site and the CodePlex community.

This dissertation contributes empirical materials from the descriptions of everyday activities of the three groups and analytic materials generated from the activity awareness and claims analyses that are translated into design representations. Specifically the contributions include (1) mechanisms of articulation work of the three groups and how the mechanisms contribute to the design representation; (2) the demonstration of a translation science in computersupported cooperative work (CSCW) and human-computer interaction (HCI); and (3) an understanding of how UX activities and software engineering activities integrate.},
	keywords = {codeplex},
	author = {Bach, Paula}
}
@article {1238,
	title = {Teaching Software Engineering with Free/Libre Open Source Projects},
	journal = {International Journal of Open Source Software and Processes},
	volume = {1},
	year = {2009},
	month = {31/2009},
	pages = {72 - 90},
	abstract = {One of the major problems in software engineering education is the involvement of students in real world software projects. Industry projects are a solution, but in many cases they are hard to find and student participation can be problematic due to cultural, familiarization and other practical reasons. The abundance of Free / Libre Open Source Software (FLOSS) projects is a neat solution, offering multi-lingual, multicultural environments in virtually every application domain, at different levels of project size, maturity, organization etc. The paper analyzes how acquisition of practical experience on several basic and advanced software engineering topics can be achieved by working in a FLOSS project. The kind of skills that can be acquired are those requested by the Overview Report for Computing Curricula by ACM and topics examined are those of the Software Engineering Body of Knowledge, by IEEE. Also software engineering areas that require special care or that may not prove suitable for such treatment are identified. Various isolated teaching cases pertaining to this approach are presented and discussed.},
	keywords = {curriculum, education, teaching, undergraduate},
	issn = {1942-3934},
	doi = {10.4018/jossp.2009010105},
	author = {Ioannis Stamelos}
}
@conference {926,
	title = {Tracking concept drift of software projects using defect prediction quality},
	booktitle = {2009 6th IEEE International Working Conference on Mining Software Repositories (MSR)2009 6th IEEE International Working Conference on Mining Software Repositories},
	year = {2009},
	pages = {51 - 60},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Vancouver, BC, Canada},
	abstract = {Defect prediction is an important task in the mining of software repositories, but the quality of predictions varies strongly within and across software projects. In this paper we investigate the reasons why the prediction quality is so fluctuating due to the altering nature of the bug (or defect) fixing process. Therefore, we adopt the notion of a concept drift, which denotes that the defect prediction model has become unsuitable as set of influencing features has changed - usually due to a change in the underlying bug generation process (i.e., the concept). We explore four open source projects (Eclipse, OpenOffice, Netbeans and Mozilla) and construct file-level and project-level features for each of them from their respective CVS and Bugzilla repositories. We then use this data to build defect prediction models and visualize the prediction quality along the time axis. These visualizations allow us to identify concept drifts and - as a consequence - phases of stability and instability expressed in the level of defect prediction quality. Further, we identify those project features, which are influencing the defect prediction quality using both a tree induction-algorithm and a linear regression model. Our experiments uncover that software systems are subject to considerable concept drifts in their evolution history. Specifically, we observe that the change in number of authors editing a file and the number of defects fixed by them contribute to a project{\textquoteright}s concept drift and therefore influence the defect prediction quality. Our findings suggest that project managers using defect prediction models for decision making should be aware of the actual phase of stability or instability due to a potential concept drift.},
	keywords = {bugzilla, cvs, defect prediction, eclipse, mozilla, netbeans, openoffice},
	isbn = {978-1-4244-3493-0},
	doi = {10.1109/MSR.2009.5069480},
	attachments = {https://flosshub.org/sites/flosshub.org/files/51MSR2009_0111_Ekanayake_Jayalath.pdf},
	author = {Ekanayake, Jayalath and Tappolet, Jonas and Gall, Harald C. and Bernstein, Abraham}
}
@article {Fang:2009:USP:1554441.1554443,
	title = {Understanding Sustained Participation in Open Source Software Projects},
	journal = {J. Manage. Inf. Syst.},
	volume = {25},
	year = {2009},
	month = {April},
	pages = {9{\textendash}50},
	publisher = {M. E. Sharpe, Inc.},
	address = {Armonk, NY, USA},
	abstract = {Prior research into open source software (OSS) developer participation has emphasized individuals{\textquoteright} motivations for joining these volunteer communities, but it has failed to explain why people stay or leave in the long run. Building upon Lave and Wenger{\textquoteright}s theory of legitimate peripheral participation (LPP), this paper offers a longitudinal investigation of one OSS community in which sustained participation is hypothesized to be associated with the coevolution of two major elements of LPP theory: "situated learning" (the process of acting knowledgeably and purposefully in the world) and "identity construction" (the process of being identified within the community). To test this hypothesis, data were collected from multiple sources, including online public project documents, electronic mail messages, tracker messages, and log files. Results from qualitative analyses revealed that initial conditions to participate did not effectively predict long-term participation, but that situated learning and identity construction behaviors were positively linked to sustained participation. Furthermore, this study reveals that sustained participants distinguished themselves by consistently engaging in situated learning that both made conceptual (advising others) and practical contributions (improving the code). Implications and future research are discussed.},
	keywords = {Communities Of Practice, Legitimate Peripheral Participation, Open Source Projects, Open Source Software Community, Qualitative Study},
	issn = {0742-1222},
	doi = {10.2753/MIS0742-1222250401},
	url = {http://portal.acm.org/citation.cfm?id=1554441.1554443},
	author = {Fang, Yulin and Neufeld, Derrick}
}
@article {10.1109/HICSS.2009.998,
	title = {Understanding the Nature and Production Model of Hybrid Free and Open Source Systems: The Case of Varnish},
	journal = {42nd Hawaii International Conference on System Sciences (HICSS 2009)},
	year = {2009},
	pages = {1-11},
	publisher = {IEEE Computer Society},
	address = {Los Alamitos, CA, USA},
	abstract = {This is a detailed interpretive case study analysis of an open source software project, called Varnish. The conceptual framework is based on the literature covering issues of commons based production models and the organization of open source projects. The comparative analysis reveals that Varnish is a hybrid project, encompassing the features of open source software while managed by a company as a proprietary project would. It is also hybrid in the sense that it employs a combination of hierarchical and commons based peer production model features. This mix of characters addresses a variety of problems related to each of the aforementioned categories.},
	keywords = {case study, organizational sponsorship, peer production, varnish},
	isbn = {978-0-7695-3450-3},
	doi = {http://doi.ieeecomputersociety.org/10.1109/HICSS.2009.998},
	attachments = {https://flosshub.org/sites/flosshub.org/files/07-07-02.pdf},
	author = {Zegaye Seifu Wubishet}
}
@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 {940,
	title = {Using Latent Dirichlet Allocation for automatic categorization of software},
	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 = {163 - 166},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Vancouver, BC, Canada},
	abstract = {In this paper, we propose a technique called LACT for automatically categorizing software systems in open-source repositories. LACT is based on latent Dirichlet Allocation, an information retrieval method which is used to index and analyze source code documents as mixtures of probabilistic topics. For an initial evaluation, we performed two studies. In the first study, LACT was compared against an existing tool, MUDABlue, for classifying 41 software systems written in C into problem domain categories. The results indicate that LACT can automatically produce meaningful category names and yield classification results comparable to MUDABlue. In the second study, we applied LACT to 43 software systems written in different programming languages such as C/C++, Java, C$\#$, PHP, and Perl. The results indicate that LACT can be used effectively for the automatic categorization of software systems regardless of the underlying programming language or paradigm. Moreover, both studies indicate that LACT can identify several new categories that are based on libraries, architectures, or programming languages, which is a promising improvement as compared to manual categorization and existing techniques.},
	keywords = {categorization, category mining, lact, mudablue, multiple languages, repository},
	isbn = {978-1-4244-3493-0},
	doi = {10.1109/MSR.2009.5069496},
	attachments = {https://flosshub.org/sites/flosshub.org/files/163MSR2009_TianPos.pdf},
	author = {Tian, Kai and Revelle, Meghan and Poshyvanyk, Denys}
}
@article {10.1109/HICSS.2009.1014,
	title = {Using Software Archaeology to Measure Knowledge Loss in Software Projects Due to Developer Turnover},
	journal = {2009 42nd Hawaii International Conference on System Sciences (HICSS 2009)},
	year = {2009},
	pages = {1-10},
	publisher = {IEEE Computer Society},
	address = {Los Alamitos, CA, USA},
	abstract = {Developer turnover can result in a major problem when developing software. When senior developers abandon a software project, they leave a knowledge gap that has to be managed. In addition, new (junior) developers require some time in order to achieve the desired level of productivity. In this paper, we present a methodology to measure the effect of knowledge loss due to developer turnover in software projects. For a given software project, we measure the quantity of code that has been authored by developers that do not belong to the current development team, which we define as orphaned code. Besides, we study how orphaned code is managed by the project. Our methodology is based on the concept of software archaeology, a derivation of software evolution. As case studies we have selected four FLOSS (free, libre, open source software) projects, from purely driven by volunteers to company-supported. The application of our methodology to these case studies will give insight into the turnover that these projects suffer and how they have managed it and shows that this methodology is worth being augmented in future research.},
	keywords = {attrition, case study, developers, evince, evolution, gimp, growth, knowledge collaboration, lines of code, nautilus, quality, sloc, turnover},
	isbn = {978-0-7695-3450-3},
	doi = {http://doi.ieeecomputersociety.org/10.1109/HICSS.2009.1014},
	attachments = {https://flosshub.org/sites/flosshub.org/files/07-07-08.pdf},
	author = {Izquierdo-Cortazar, Daniel and Gregorio Robles and Ortega, Felipe and Jesus M. Gonzalez-Barahona}
}
@conference {933,
	title = {Visualizing Gnome with the Small Project Observatory},
	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 = {103 - 106},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Vancouver, BC, Canada},
	abstract = {We analyzed the gnome family of systems with the small project observatory, our online ecosystem visualization platform. We begin by briefly introducing the model of SPO. We then observe and discuss several phases in the activity of the gnome ecosystem. We follow and look at how the contributors are distributed between writing source code and doing other activities such as internationalization. We end with a visual overview of the activity of more than 900 contributors in the 10 years of existence of gnome.},
	keywords = {bugzilla, contributions, gnome, msr challenge, spo, visualization},
	isbn = {978-1-4244-3493-0},
	doi = {10.1109/MSR.2009.5069487},
	attachments = {https://flosshub.org/sites/flosshub.org/files/103Lung2009a.pdf},
	author = {Lungu, Mircea and Malnati, Jacopo and Lanza, Michele}
}
@conference {939,
	title = {On what basis to recommend: Changesets or interactions?},
	booktitle = {2009 6th IEEE International Working Conference on Mining Software Repositories (MSR)2009 6th IEEE International Working Conference on Mining Software Repositories},
	year = {2009},
	pages = {155 - 158},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Vancouver, BC, Canada},
	abstract = {Different flavours of recommendation systems have been proposed to help software developers perform software evolution tasks. A number of these recommendation systems are based on changesets. When changeset information is used, recommendations are based on only the end result of the activity undertaken to complete a task. In this paper, we report on an investigation that compared how recommendations based on changesets compare to recommendations based on interactions collected as a programmer performed the task that resulted in a changeset. To provide a common basis for the comparison, our investigation considered how bug reports considered similar based on changeset information compare to bug reports considered similar based on interaction information. We found that there is no direct relationship between the bug reports found similar with the different methods, suggesting that each comparison methods captures a different aspect of the problem.},
	keywords = {bug reports, changeset, eclipse, mylyn},
	isbn = {978-1-4244-3493-0},
	doi = {10.1109/MSR.2009.5069494},
	author = {Rastkar, Sarah and Murphy, Gail C.}
}
@conference {851,
	title = {Wikipedians are born, not made: a study of power editors on Wikipedia},
	booktitle = {ACM 2009 International Conference on Group Work},
	year = {2009},
	month = {05/10/2009},
	pages = {51-60},
	publisher = {Association for Computing Machinery},
	organization = {Association for Computing Machinery},
	address = {Sanibel Island, FL},
	keywords = {computer-supported, cooperative, interaction, web-based, work,},
	author = {Panciera, K. and Halfaker, A. and Terveen, L.}
}
@article {denBesten2008316,
	title = {The allocation of collaborative efforts in open-source software},
	journal = {Information Economics and Policy},
	volume = {20},
	number = {4},
	year = {2008},
	note = {"we have selected a set of 10 large open-source projects"
apache, cvs, gaim, gcc, ghostscript, mozilla, netbsd, openssh, postgresql, python
"Our data were extracted from logs of development activity generated by software version control systems. For each project in the selection, we extracted CVS development logs"
"We notably computed for each file in the sample, and for each month in its history, the number of distinct maintainers that had committed a change during that month, and the number of commits, the blocks of code addition, each file had received during that month."
"other variables used in the regressions are proxies for the size, age, and granularity of files; the size of a file is represented as its number of lines of code (LOCs), its age by its creation date (Youth), and its granularity by the number of functions it contains."},
	pages = {316 - 322},
	abstract = {The article investigates the allocation of collaborative efforts among core developers (maintainers) of open-source software by analyzing on-line development traces (logs) for a set of 10 large projects. Specifically, we investigate whether the division of labor within open-source projects is influenced by characteristics of software code. We suggest that the collaboration among maintainers tends to be influenced by different measures of code complexity. We interpret these findings by providing preliminary evidence that the organization of open-source software development would self-adapt to characteristics of the code base, in a {\textquoteright}stigmergic{\textquoteright} manner.},
	keywords = {age, apache, complexity, cvs, division of labor, functions, gaim, gcc, ghostscript, lines of code, loc, log files, mozilla, netbsd, openssh, postgresql, python, revision control, scm, size, source code, Stigmergy, version control},
	issn = {0167-6245},
	doi = {DOI: 10.1016/j.infoecopol.2008.06.003},
	url = {http://www.sciencedirect.com/science/article/B6V8J-4SSG4PN-1/2/88b3824c30a31c18929d8a5ca6d64f62},
	author = {den Besten, Matthijs and Jean-Michel Dalle and Galia, Fabrice}
}
@conference {Wermelinger:2008:AEE:1370750.1370783,
	title = {Analyzing the evolution of eclipse plugins},
	booktitle = {Proceedings of the 2008 international working conference on Mining software repositories},
	series = {MSR {\textquoteright}08},
	year = {2008},
	pages = {133{\textendash}136},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {Eclipse is a good example of a modern component-based complex system that is designed for long-term evolution, due to its architecture of reusable and extensible components. This paper presents our preliminary results about the evolution of Eclipse{\textquoteright}s architecture, based on a lightweight and scalable analysis of the metadata in Eclipse{\textquoteright}s sources. We find that the development of Eclipse follows a systematic process: most architectural changes take place in milestones, and maintenance releases only make exceptional changes to component dependencies. We also found a stable architectural core that remains since the first release.},
	keywords = {architectural evolution, cvs, eclipse, metadata, msr challenge, releases, source code},
	isbn = {978-1-60558-024-1},
	doi = {http://doi.acm.org/10.1145/1370750.1370783},
	url = {http://doi.acm.org/10.1145/1370750.1370783},
	author = {Wermelinger, Michel and Yu, Yijun}
}
@conference {1211,
	title = {Are FLOSS developers committing to CVS/SVN as much as  they are talking in mailing lists? Challenges for Integrating  data from Multiple Repositories},
	booktitle = {3rd Workshop on Public Data about Software Development (WoPDaSD 2008)},
	year = {2008},
	month = {09/2008},
	pages = {49-54},
	abstract = {This paper puts forward a framework for investigating Free and Open Source Software (F/OSS) developers activities in both source code and mailing lists repositories. We used data dumps of fourteen pro jects from the FLOSSMetrics (FM) retrieval system. Our intentions are (i) to present a possible methodology, its advantages and disadvantages which can benefit future researchers using some aspects of the FM retrieval system{\textquoteright}s data dumps, and (ii) discuss our initial research results on the contributions developers make to both coding and lists activities.},
	keywords = {cvs, cvsanaly, developers, email, email archives, flossmetrics, mailing list, mlstats, source code},
	attachments = {https://flosshub.org/sites/flosshub.org/files/49-542008.pdf},
	author = {Sowe, Sulayman K. and Samoladas, Ioannis and Ioannis Stamelos and Lefteris Angelis}
}
@conference {971,
	title = {Branching and merging in the repository},
	booktitle = {the 2008 international workshopProceedings of the 2008 international workshop on Mining software repositories  - MSR {\textquoteright}08},
	year = {2008},
	month = {05/2008},
	pages = {19-22},
	publisher = {ACM Press},
	organization = {ACM Press},
	address = {New York, New York, USA},
	abstract = {Two of the most complex operations version control software allows a user to perform are branching and merging. Branching provides the user the ability to create a copy of the source code to allow changes to be stored in version control but outside of the trunk. Merging provides the user the ability to copy changes from a branch to the trunk. Performing a merge can be a tedious operation and one that may be error prone. In this paper, we compare file revisions found on branches with those found on the trunk to determine when a change that is applied to a branch is moved to the trunk. This will allow us to study how developers use merges and to determine if merges are in fact more error prone than other commits.},
	keywords = {argouml, changes, cvs2svn, diffj, revision, scm, source code, version control},
	isbn = {9781605580241},
	doi = {10.1145/1370750.1370754},
	attachments = {https://flosshub.org/sites/flosshub.org/files/p19-williams.pdf},
	author = {Spacco, Jamie and Williams, Chadd C.}
}
@article {Crowston:2008,
	title = {Bug Fixing Practices within Free/Libre Open Source Software Development Teams},
	journal = {Journal of Database Management},
	volume = {19},
	number = {2},
	year = {2008},
	note = {"Projects to be studied were selected from those hosted on SourceForge, (http://sourceforge.net/)"
"we chose projects for which data we need for our analysis are publicly available, meaning a large number of bug reports"
"we chose teams with more than 8 developers"
"Only 140 projects of SourceForge met the first two requirements in 2002 when we drew our sample"
kicq, gaim, phpmyadmin, dynapi
"First, we obtained data indica- tive of the effectiveness of each project, such as its level of activity, number of downloads and development status"
"we elected to use objective data about the bug- fixing process. Hence, the main source of data about the bug-fixing process was obtained from the archives of the bug tracking system, which is the tool used to support the bug-fixing process"},
	pages = {1{\textendash}30},
	abstract = {Free/libre open source software (FLOSS, e.g., Linux or Apache) is primarily developed by distributed teams. Developers contribute from around the world and coordinate their activity almost exclusively by means of email and bulletin boards, yet some how profit from the advantages and evade the challenges of distributed software development. In this article we investigate the structure and the coordination practices adopted by development teams during the bug-fixing process, which is considered one of main areas of FLOSS project success. In particular, based on a codification of the messages recorded in the bug tracking system of four projects, we identify the accomplished tasks, the adopted coordination mechanisms, and the role undertaken by both the FLOSS development team and the FLOSS community. We conclude with suggestions for further research.},
	keywords = {activity, bug tracker, bug tracking system, coordination, downloads, dynapi, effectiveness, FLOSS, gaim, kicq, phpmyadmin, project success, size, status},
	issn = {1063-8016},
	attachments = {https://flosshub.org/sites/flosshub.org/files/CrowstonScozziJDBM2008.pdf},
	author = {Kevin Crowston and Barbara Scozzi}
}
@article {1391,
	title = {Challenges and strategies in the use of Open Source Software by Independent Software Vendors},
	journal = {Information and Software Technology},
	volume = {50},
	year = {2008},
	month = {8/2008},
	pages = {991 - 1002},
	abstract = {Open Source Software (OSS) has already been adopted by a large number of organizations. An important {\textendash} but sometimes neglected {\textendash} group of OSS users are Independent Software Vendors (ISVs). ISVs often develop their applications on top of OSS platform software. Frequently, this requires making several extensions and modifications to these OSS components. We identify a number of challenges that ISVs face in handling these extensions and modifications. Next, we describe several strategies ISVs can follow in maintaining these modifications. Finally, we suggest an opportunity for a closer collaboration between OSS projects and ISVs which could be mutually beneficial.},
	keywords = {Contributing, Independent Software Vendor},
	issn = {09505849},
	doi = {10.1016/j.infsof.2007.09.001},
	author = {Ven, Kris and Mannaert, Herwig}
}
@conference {1206,
	title = {Collecting data from distributed FOSS projects},
	booktitle = {3rd Workshop on Public Data about Software Development (WoPDaSD 2008)},
	year = {2008},
	note = {"We selected three projects from the initial set of projects: Linux 2.6, an operating system kernel, gimp, a graphics program, and Blender, a 3d content creation suite."
"To acquire data from each data source, we wrote special programs based on the earlier prototypes....The first program extracts information from mailing list archives....The second program obtains bug reports from bug tracking systems....The third program obtains source code from network-accessible version control systems and runs metric calculations on it."},
	month = {2009},
	pages = {8-13},
	abstract = {A key trait of Free and Open Source Software (foss) development is its distributed nature. Nevertheless, two project-level operations, the fork and the merge of program code, are among the least well understood events in the lifespan of a foss project. Some projects have explicitly adopted these operations as the primary means of concurrent development. In this study, we examine the effect of highly distributed software development, as found in the Linux kernel project, on collection and modelling of software development data. We find that distributed development calls for sophisticated temporal modelling techniques where several versions of the source code tree can exist at once. Attention must be turned towards the methods of quality assurance and peer review that projects employ to manage these parallel source trees. Our analysis indicates that two new metrics, fork rate and merge rate, could be useful for determining the role of distributed version control systems in foss projects. The study 
presents a preliminary data set consisting of version control and mailing list data. },
	keywords = {bitkeeper, bug tracking system, cvs, distributed, email archive, fork rate, git, life cycle, linux, linux kernel, mailing list, merge rate, subversion, svn, version control},
	attachments = {https://flosshub.org/sites/flosshub.org/files/fagerholm.pdf},
	author = {Fagerholm, Fabian and Taina, Juha}
}
@conference {970,
	title = {Determinism and evolution},
	booktitle = {Proceedings of the 2008 international workshop on Mining software repositories  - MSR {\textquoteright}08},
	year = {2008},
	month = {05/2008},
	pages = {1-9},
	publisher = {ACM Press},
	organization = {ACM Press},
	address = {New York, New York, USA},
	abstract = {It has been proposed that software evolution follows a Self-Organized Criticality (SOC) dynamics. This fact is supported by the presence of long range correlations in the time series of the number of changes made to the source code over time. Those long range correlations imply that the current state of the project was determined time ago. In other words, the evolution of the software project is governed by a sort of determinism. But this idea seems to contradict intuition. To explore this apparent contradiction, we have performed an empirical study on a sample of 3,821 libre (free, open source) software projects, finding that their evolution projects is short range correlated. This suggests that the dynamics of software evolution may not be SOC, and therefore that the past of a project does not determine its future except for relatively short periods of time, at least for libre software.},
	keywords = {changes, evolution, source code, sourceforge},
	isbn = {9781605580241},
	doi = {10.1145/1370750.1370752},
	attachments = {https://flosshub.org/sites/flosshub.org/files/p1-herraiz.pdf},
	author = {Gonz{\'a}lez-Barahona, Jes{\'u}s M. and Gregorio Robles and Herraiz, Israel}
}
@article {1084,
	title = {Dynamics of innovation in an "open source" collaboration environment: lurking, laboring, and launching FLOSS projects on SourceForge},
	journal = {Industrial and Corporate Change},
	volume = {17},
	year = {2008},
	note = {"For the purposes of this study, we are able to draw upon micro-level data pertaining to the activities undertaken during the period between the beginning of September 2000 and December 2002 by the entire cohort of 222,835 individuals who had registered on SF.net during the 14 months from September 1, 2000 through October 26, 2001."
"The statistical analysis in this article is based upon an edited dataset (referred to here as the SFnetDataset) covering the SourceForge cohort of 222,835 individuals who registered on SF.net during the 14 months from September 1, 2000 through October 26, 2001."
They appear to be using their own dataset which is from 2000-2001 even though this paper is from 2008},
	month = {07/2008},
	pages = {647 - 710},
	abstract = {A systems analysis perspective is adopted to examine the critical properties of the Free/Libre/Open Source Software (FLOSS) mode of innovation, as reflected on the SourceForge platform (SF.net). This approach re-scales March{\textquoteright}s (1991) framework and applies it to characterize the {\textquotedblleft}innovation system{\textquotedblright} of a {\textquotedblleft}distributed organization{\textquotedblright} of interacting agents in a virtual collaboration environment, rather than to innovation within a firm. March (1991) views the process of innovation at the organizational level as the coupling of sub-processes of exploration and exploitation. Correspondingly, the innovation system of the virtual collaboration environment represented by SF.net is an emergent property of two {\textquotedblleft}coupled{\textquotedblright} processes: one involves the interactions among agents searching the locale for information and knowledge resources to use in designing novel software products (i.e., exploration), and the other involves the mobilization of individuals{\textquoteright} capabilities for application in the software development projects that become established on the platform (i.e., exploitation). The micro-dynamics of this system are studied empirically by constructing transition probability matrices representing the movements of 222,835 SF.net users among seven different activity states, which range from {\textquotedblleft}lurking{\textquotedblright} (not contributing or contributing to projects without becoming a member) to {\textquotedblleft}laboring{\textquotedblright} (joining one or more projects as members), and to {\textquotedblleft}launching{\textquotedblright} (founding one or more projects) within each successive 6-month interval. The estimated probabilities are found to form first-order Markov chains describing ergodic processes. This makes it possible the computation of the equilibrium distribution of agents among the states, thereby suppressing transient effects and revealing persisting patterns of project joining and project launching. The latter show the FLOSS innovation process on SF.net to be highly dissipative: a very large proportion of the registered {\textquotedblleft}developers{\textquotedblright} fail to become even minimally active on the platform. There is nevertheless an active core of mobile project joiners, and a (still smaller) core of project founders who persist in creating new projects. The structure of these groups{\textquoteright} interactions (as displayed within the 3-year period examined) is investigated in detail, and it is shown that it would be sufficient to sustain both the exploration and exploitation phases of the platform{\textquoteright}s global dynamics.},
	keywords = {contributors, core, developers, roles, SFnetDataset, sourceforge, users, virtual communities, virtual organization, virtual organizations},
	issn = {1464-3650},
	doi = {10.1093/icc/dtn026},
	author = {David, P. A. and Rullani, F.}
}
@article {Koch2008345,
	title = {Effort modeling and programmer participation in open source software projects},
	journal = {Information Economics and Policy (Empirical Issues in Open Source Software)},
	volume = {20},
	number = {4},
	year = {2008},
	note = {"Using a two-step approach, first a detailed case study on one project, GNOME, will be undertaken, then a large data set retrieved from a project hosting site, SourceForge.net, will be used to validate the results."

CVS was the main source of data

"e-mails sent to the different project discussion lists were identified as an additional source of information especially on communication and coordination besides the CVS-repository"

basic counts were calculated for developer discussion levels},
	month = {12/2008},
	pages = {345 - 355},
	abstract = {This paper develops models for programmer participation and effort estimation in open source software projects and employs the results to assess the efficiency of open source software creation. Successful development of such models will be important for decision makers of various kinds. We propose hypotheses based on a prior case study on manpower function and effort modeling. A large data set retrieved from a project repository is used to test these hypotheses. The main results are that if Norden-Rayleigh-based approaches are used, they need to be complemented in order to account for the addition of new features during a product life cycle, and that programmer-participation based effort models result in distinctly lower estimations of effort than those based on output metrics, such as lines of code.},
	keywords = {cvs, developers, email, email archives, gnome, lines of code, scm, Software repository mining, source code, sourceforge},
	issn = {0167-6245},
	doi = {DOI: 10.1016/j.infoecopol.2008.06.004},
	url = {http://www.sciencedirect.com/science/article/B6V8J-4SSND1J-1/2/c857fa1493e19aa7fe4297dedb077b3a},
	attachments = {https://flosshub.org/sites/flosshub.org/files/KochEffortModeling.pdf},
	author = {Koch, Stefan}
}
@conference {Chang:2008:ESC:1370750.1370766,
	title = {Evaluation of source code copy detection methods on freebsd},
	booktitle = {Proceedings of the 2008 international working conference on Mining software repositories},
	series = {MSR {\textquoteright}08},
	year = {2008},
	month = {05/2008},
	pages = {61{\textendash}66},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {Studies have shown that substantial code reuse is common in open source and in commercial projects. However, the precise extent of reuse and its impact on productivity and quality are not well investigated in the open source context. Previously, we have introduced a simple-to-use method that needs only a set of file pathnames to identifies directories that share filenames and partially validated its performance on a set of closed-source projects. To evaluate this method and to improve reuse detection at the file level, we apply it and four additional file copy detection methods that utilize the underlying content of multiple versions of the source code on the FreeBSD project. The evaluation quantified unique advantages of each method and showed that the filename method detected roughly half of all reuse cases. We are still faced with a challenge to scale the content based methods to large repositories containing all versions of open source files.},
	keywords = {clone, cloning, code copying, freebsd, version control},
	isbn = {978-1-60558-024-1},
	doi = {http://doi.acm.org/10.1145/1370750.1370766},
	url = {http://doi.acm.org/10.1145/1370750.1370766},
	attachments = {https://flosshub.org/sites/flosshub.org/files/p61-chang.pdf},
	author = {Chang, Hung-Fu and Audris Mockus}
}
@conference {Alonso:2008:EIV:1370750.1370780,
	title = {Expertise identification and visualization from CVS},
	booktitle = {Proceedings of the 2008 international working conference on Mining software repositories},
	series = {MSR {\textquoteright}08},
	year = {2008},
	month = {05/2008},
	pages = {125{\textendash}128},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {As software evolves over time, the identification of expertise becomes an important problem. Component ownership and team awareness of such ownership are signals of solid project. Ownership and ownership awareness are also issues in open-source software (OSS) projects. Indeed, the membership in OSS projects is dynamic with team members arriving and leaving. In large open source projects, specialists who know the system very well are considered experts. How can one identify the experts in a project by mining a particular repository like the source code? Have they gotten help from other people?

We provide an approach using classification of the source code tree as a path to derive the expertise of the committers. Because committers may get help from other people, we also retrieve their contributors. We also provide a visualization that helps to further explore the repository via committers and categories. We present a prototype implementation that describes our research using the Apache HTTP Web server project as a case study.},
	keywords = {apache, classification, committers, components, contributors, expertise, expertise identification, repository, scm, source code},
	isbn = {978-1-60558-024-1},
	doi = {http://doi.acm.org/10.1145/1370750.1370780},
	url = {http://doi.acm.org/10.1145/1370750.1370780},
	attachments = {https://flosshub.org/sites/flosshub.org/files/p125-alonso.pdf},
	author = {Alonso, Omar and Premkumar T. Devanbu and Gertz, Michael}
}
@article {Giuri2008305,
	title = {Explaining leadership in virtual teams: The case of open source software},
	journal = {Information Economics and Policy},
	volume = {20},
	number = {4},
	year = {2008},
	note = {Empirical Issues in Open Source Software},
	pages = {305 - 315},
	abstract = {This paper contributes to the open source software (OSS) literature by investigating the likelihood that a participant becomes a project leader. Project leaders are key actors in a virtual community and are crucial to the success of the OSS model. Knowledge of the forces that lead to the emergence of project managers among the multitude of participants is still limited. We aim to fill this gap in the literature by analyzing the association between the roles played by an individual who is registered with a project, and a set of individual-level and project-level characteristics. In line with the theory of occupational choice elaborated by (Lazear, E.P., 2002. Entrepreneurship. NBER Working Paper No. 9109, Cambridge, Mass; Lazear, E.P., 2004. Balanced skills and entrepreneurship, American Economic Review 94, pp. 208-211), we find that OSS project leaders possess diversified skill sets which are needed to select the inputs provided by various participants, motivate contributors, and coordinate their efforts. Specialists, like pure developers, are endowed with more focused skill sets. Moreover, we find that the degree of modularity of the development process is positively associated with the presence of project leaders. That result is consistent with the modern theory of modular production (Baldwin, C.Y., Clark, K.B., 1997. Managing in an age of modularity. Harvard Business Review September-October. pp. 84-93; Mateos-Garcia, J., Steinmueller, W.E., 2003. The Open Source Way of Working: A New Paradigm for the Division of Labour in Software Development? SPRU - Science and Technology Policy Studies. Open Source Movement Research INK Working Paper, No. 1; Aoki, M., 2004. An organizational architecture of T-form: Silicon Valley clustering and its institutional coherence. Industrial and Corporate Change 13, pp. 967-981).},
	keywords = {contributors, Human capital, leadership, roles, sourceforge, team},
	issn = {0167-6245},
	doi = {DOI: 10.1016/j.infoecopol.2008.06.002},
	url = {http://www.sciencedirect.com/science/article/B6V8J-4SRW10C-1/2/5ce36096ba3947338962268b54a5a7a9},
	author = {Paola Giuri and Francesco Rullani and Salvatore Torrisi}
}
@booklet {481,
	title = {How Do Firms Make Use of Open Source Communities?},
	howpublished = {Long Range Planning},
	volume = {41},
	number = {6},
	year = {2008},
	note = {"To obtain more information about the firms{\textquoteright} relationships with their respective communities, we followed mailing lists and forums over a three-month period, checking them at least three times a week. "
"Firm data. Secondary sources, including annual reports, company directories, business and specialist press and homepages, were used to gather information on firms"},
	month = {Dec},
	pages = {629-649},
	abstract = {Relying on four in-depth case studies of firms involved with open source software, we investigate how firms make use of open source communities, and how that use is associated with their business models. Three themes - accessing, aligning and assimilating -are inductively developed for how the firms relate to the external knowledge created in the communities. For each theme, we make an argument about the tactics associated with each theme and their positive and negative consequences. The findings are related to the literature on the open and distributed nature of innovation, and various theoretical and managerial implications are discussed.},
	keywords = {case study, cendio, email, mailing list, mysql, roxen, secondary data, sot},
	url = {http://www.acm.jhu.edu/~paulproteus/tmp/sdarticle.pdf},
	attachments = {https://flosshub.org/sites/flosshub.org/files/dahlandermagnusson2008.pdf},
	author = {Linus Dahlander and M Magnusson}
}
@conference {Parnin:2008:ICD:1370750.1370765,
	title = {Improving change descriptions with change contexts},
	booktitle = {Proceedings of the 2008 international working conference on Mining software repositories},
	series = {MSR {\textquoteright}08},
	year = {2008},
	month = {05/2008},
	pages = {51{\textendash}60},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {Software archives are one of the best sources available to researchers for understanding the software development process. However, much detective work is still necessary in order to unravel the software development story. During this process, researchers must isolate changes and follow their trails over time. In support of this analysis, several research tools have provided different representations for connecting the many changes extracted from software archives. Most of these tools are based on textual analysis of source code and use line-based differencing between software versions. This approach limits the ability to process changes structurally resulting in less concise and comparable items. Adoption of structure-based approaches have been hampered by complex implementations and overly verbose change descriptions. We present a technique for expressing changes that is fine-grained but preserves some structural aspects. The structural information itself may not have changed, but instead provides a context for interpreting the change. This in turn, enables more relevant and concise descriptions in terms of software types and programming activities. We apply our technique to common challenges that researchers face, and then we discuss and compare our results with other techniques.},
	keywords = {bytecode analysis, cecil, change management, change pairs, semantic diff, zedgraph},
	isbn = {978-1-60558-024-1},
	doi = {http://doi.acm.org/10.1145/1370750.1370765},
	url = {http://doi.acm.org/10.1145/1370750.1370765},
	attachments = {https://flosshub.org/sites/flosshub.org/files/p51-parnin.pdf},
	author = {Parnin, Chris and G{\"o}rg, Carsten}
}
@conference {flosswp1737,
	title = {Improving community awareness in software forges by semantical aggregation of tools feeds},
	booktitle = {3nd International Workshop on Public Data about Software Development (WoPDaSD 2008), Milano, Italy, September 2008},
	year = {2008},
	abstract = {It is rather difficult to monitor or visualize what can be the contribution of a member in a project, especially when the project uses multiple tools to produce its results. This is the case for collaborative development of FLOSS software, that use Wiki, bug tracker, mailing lists and source code management tools. This paper presents an approach to data collection by using aggregation of feeds published by the different tools of a software forge. To allow this aggregation, collected data is semantically reformatted into Semantic Web standards: RDF, DC, DOAP, and FOAF. Resulting data can then be processed, republished or displayed to project members. We implemented this approach in a supervision module that has been integrated into the PicoForge platform. This module is able do draw a live graph of the social community out of the different sources of data, and in turn export semantic feeds for other uses.},
	keywords = {community of practice, DOAF., FOAF, free and open source software development, public data, RDF, semantic Web, social filtering, social network analysis},
	attachments = {https://flosshub.org/sites/flosshub.org/files/Paper4.pdf},
	author = {Quang Vu Dang and Christian Bac and Olivier Berger and Xuan Sang Dao}
}
@article {1120,
	title = {The institutions of open source software: Examining the Debian community*},
	journal = {Information Economics and Policy},
	volume = {20},
	year = {2008},
	note = {"using primary data from its mailing lists archives, handbooks written to inform potential and actual community members, and previous analyses of institutional evolution and political conflict"

no discussion of which lists, how many, or when they were gathered...?[ms]},
	month = {12/2008},
	pages = {333 - 344},
	abstract = {Free and open source software activities involve and, perhaps, evolve institutions (rules, norms and standards) that influence the formation, growth, and demise of communities. Community institutions are attractors for some individuals while discouraging other individuals from entering or continuing to participate. Their suitability may change as a community grows. This paper examines the institutions of the Debian community where issues of community identity, distribution of authority, and decentralisation have facilitated growth and development. These same institutions have also resulted in conflicts regarding community purposes and the quality and delivery of the community{\textquoteright}s output. We examine the institutional redesign undertaken to address these problems and derive implications for F/LOS communities and companies.},
	keywords = {authority, COMMUNITY, conflict, debian, decentralization, growth, institutions, leadership},
	issn = {01676245},
	doi = {10.1016/j.infoecopol.2008.06.001},
	attachments = {https://flosshub.org/sites/flosshub.org/files/The_institutions_of_open_source_software-_IR.pdf},
	author = {Mateos Garcia, J. and Steinmueller, W.E.}
}
@article {499,
	title = {The Material and Social Dynamics of Motivation: Contributions to Open Source Language Technology Development},
	journal = {Science Studies},
	number = {2},
	year = {2008},
	note = {"I conducted a two-phased qualitative analysis on multiple data (thematic phone-inter- views, notes from OpenOffice.org conference 2004 meetings, historical documents, mailing list discussions, homepages, Google, blogs, real-time video and audio presentations from OpenOffice.org conference 2005)."},
	abstract = {Volunteer motivation has been a central theme in Free/Libre/Open Source Software (FLOSS) literature. This research has been largely dominated by economists who rely in their surveys on the distinction between intrinsic and extrinsic motivations and the "hacker ethic" for profit juxtaposition. The paper argues that survey-based analytical frameworks and research designs have led to a focus on some motivational attributions at the expense of others. It then presents a case study that explores dynamic, non individualistic and content-sensitive aspects of motivations. The approach is based on socio-cultural psychology and the author{\textquoteright}s observations of a hybrid firm-community FLOSS project, OpenOffice.org. Instead of separating intrinsic motivations from extrinsic ones, it is argued that complex and changing patterns of motivations are tied to changing objects and personal histories prior to and during participation. The boundary between work and hobby in an individual{\textquoteright}s participation path is blurred and shifting.},
	keywords = {contributions, developers, email, email archives, mailing list, MOTIVATION, openoffice, openoffice.org, secondary data, Volunteers},
	attachments = {https://flosshub.org/sites/flosshub.org/files/Freeman.pdf},
	author = {Stephanie Freeman}
}
@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 {Rigby:2008:OSS:1368088.1368162,
	title = {Open source software peer review practices: a case study of the apache server},
	booktitle = {Proceedings of the 30th International Conference on Software Engineering (ICSE 2008)},
	series = {ICSE {\textquoteright}08},
	year = {2008},
	note = {http://faculty.salisbury.edu/~xswang/Research/Papers/SERelated/testing/p541-rigby.pdf},
	pages = {541{\textendash}550},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {Peer review is seen as an important quality assurance mechanism in both industrial development and the open source software (OSS) community. The techniques for performing inspections have been well studied in industry; in OSS development, peer reviews are less well understood. We examine the two peer review techniques used by the successful, mature Apache server project: review-then-commit and commit-then-review. Using archival records of email discussion and version control repositories, we construct a series of metrics that produces measures similar to those used in traditional inspection experiments. Specifically, we measure the frequency of review, the level of participation in reviews, the size of the artifact under review, the calendar time to perform a review, and the number of reviews that find defects. We provide a comparison of the two Apache review techniques as well as a comparison of Apache review to inspection in an industrial project. We conclude that Apache reviews can be described as (1) early, frequent reviews (2) of small, independent, complete contributions (3) conducted asynchronously by a potentially large, but actually small, group of self-selected experts (4) leading to an efficient and effective peer review technique.},
	keywords = {apache, cvs, email, inspection, mining software repositories (email), open source software, peer review, version control},
	isbn = {978-1-60558-079-1},
	doi = {10.1145/1368088.1368162},
	url = {http://doi.acm.org/10.1145/1368088.1368162},
	attachments = {https://flosshub.org/sites/flosshub.org/files/p541-rigby.pdf},
	author = {Peter C. Rigby and Daniel M. German and Storey, Margaret-Anne}
}
@conference {Krogstie:2008:PTB:1368088.1368201,
	title = {Power through brokering: open source community participation in software engineering student projects},
	booktitle = {Proceedings of the 30th international conference on Software engineering},
	series = {ICSE {\textquoteright}08},
	year = {2008},
	pages = {791{\textendash}800},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {Many software engineering projects use open source software tools or components. The project team{\textquoteright}s active participation in the open source community may be necessary for the team to use the technology. Based on an in-depth field study of industry software engineering project students interacting with an open source community, we find that participation in the community may affect the team{\textquoteright}s work and learning by strengthening the power of the broker between the team and the community. We outline pitfalls and benefits of having student teams acquire development-related knowledge from open source communities. The findings are relevant to the organization and supervision of software engineering student projects interacting with open source communities.},
	keywords = {Communities Of Practice, computer science education, FLOSS, open source, software engineering, software engineering education},
	isbn = {978-1-60558-079-1},
	doi = {10.1145/1368088.1368201},
	url = {http://doi.acm.org/10.1145/1368088.1368201},
	author = {Krogstie, Birgit R.}
}
@conference {WeiBgerber:2008:SPG:1370750.1370767,
	title = {Small patches get in!},
	booktitle = {Proceedings of the 2008 international working conference on Mining software repositories},
	series = {MSR {\textquoteright}08},
	year = {2008},
	month = {05/2008},
	pages = {67{\textendash}76},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {While there is a considerable amount of research on analyzing the change information stored in software repositories, only few researcher have looked at software changes contained in email archives in form of patches. In this paper we look at the email archives of two open source projects and answer questions like the following: How many emails contain patches? How long does it take for a patch to be accepted? Does the size of the patch influence its chances to be accepted or the duration until it gets accepted? Obviously, the answers to these questions can be helpful for the authors of patches, in particular because some of the answers are surprising.},
	keywords = {case study, cvs, email, email archives, flac, mailing list, openafs, patch acceptance, patches, revision control, scm},
	isbn = {978-1-60558-024-1},
	doi = {http://doi.acm.org/10.1145/1370750.1370767},
	url = {http://doi.acm.org/10.1145/1370750.1370767},
	attachments = {https://flosshub.org/sites/flosshub.org/files/p67-weissgerber.pdf},
	author = {Wei{\ss}gerber, Peter and Neu, Daniel and Diehl, Stephan}
}
@conference {Thummalapenta:2008:SDF:1370750.1370775,
	title = {SpotWeb: detecting framework hotspots via mining open source repositories on the web},
	booktitle = {Proceedings of the 2008 international working conference on Mining software repositories},
	series = {MSR {\textquoteright}08},
	year = {2008},
	month = {05/2008},
	pages = {109{\textendash}112},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {The essentials of modern software development (such as low cost and high efficiency) demand software developers to make intensive reuse of existing open source frameworks or libraries (generally referred as frameworks) available on the web. However, developers often face challenges in reusing these frameworks due to several factors such as the complexity and lack of proper documentation. In this paper, we propose a code-search-engine-based approach that tries to detect hotspots in a given framework by mining code examples gathered from open source repositories available on the web; these hotspots are the APIs that are frequently reused.

Hotspots can serve as starting points for developers in understanding and reusing the given framework. We developed a tool, called SpotWeb, for frameworks or libraries written in Java and conducted two case studies with two open source frameworks JUnit and Log4j. We also show that the detected hotspots of Log4j and JUnit are consistent with their respective documentations.},
	keywords = {code reuse, code search engine, frameworks, hotspots, junit, log4j, repositories},
	isbn = {978-1-60558-024-1},
	doi = {http://doi.acm.org/10.1145/1370750.1370775},
	url = {http://doi.acm.org/10.1145/1370750.1370775},
	attachments = {https://flosshub.org/sites/flosshub.org/files/p109-thummalapenta.pdf},
	author = {Thummalapenta, Suresh and Xie, Tao}
}
@conference {Siy:2008:SDW:1370750.1370784,
	title = {Summarizing developer work history using time series segmentation: challenge report},
	booktitle = {Proceedings of the 2008 international working conference on Mining software repositories},
	series = {MSR {\textquoteright}08},
	year = {2008},
	month = {05/2008},
	pages = {137{\textendash}140},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {Temporal segmentation partitions time series data with the intent of producing more homogeneous segments. It is a technique used to preprocess data so that subsequent time series analysis on individual segments can detect trends that may not be evident when performing time series analysis on the entire dataset.

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

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

In this paper, we present a way to summarize developer work history in terms of the files they have modified over time by segmenting the CVS change data of individual Eclipse developers. We show that the files they modify tends to change significantly over time though most of them tend to work within the same directories.},
	keywords = {contributions, cvs, developers, eclipse, msr challenge, temporal segmentation, time series, work history},
	isbn = {978-1-60558-024-1},
	doi = {http://doi.acm.org/10.1145/1370750.1370784},
	url = {http://doi.acm.org/10.1145/1370750.1370784},
	author = {Siy, Harvey and Chundi, Parvathi and Subramaniam, Mahadevan}
}
@conference {Spinellis:2008:TFK:1368088.1368140,
	title = {A tale of four kernels},
	booktitle = {Proceedings of the 30th international conference on Software engineering},
	series = {ICSE {\textquoteright}08},
	year = {2008},
	pages = {381{\textendash}390},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {The FreeBSD, GNU/Linux, Solaris, and Windows operating systems have kernels that provide comparable facilities. Interestingly, their code bases share almost no common parts, while their development processes vary dramatically. We analyze the source code of the four systems by collecting metrics in the areas of file organization, code structure, code style, the use of the C preprocessor, and data organization. The aggregate results indicate that across various areas and many different metrics, four systems developed using wildly different processes score comparably. This allows us to posit that the structure and internal quality attributes of a working, non-trivial software artifact will represent first and foremost the engineering requirements of its construction, with the influence of process being marginal, if any.},
	keywords = {comparison, freebsd, linux, open source, opensolaris, proprietary software, windows, wrk},
	isbn = {978-1-60558-079-1},
	doi = {10.1145/1368088.1368140},
	url = {http://doi.acm.org/10.1145/1368088.1368140},
	author = {Diomidis Spinellis}
}
@conference {Herraiz:2008:TSB:1370750.1370786,
	title = {Towards a simplification of the bug report form in eclipse},
	booktitle = {Proceedings of the 2008 international working conference on Mining software repositories},
	series = {MSR {\textquoteright}08},
	year = {2008},
	pages = {145{\textendash}148},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {We believe that the bug report form of Eclipse contains too many fields, and that for some fields, there are too many options. In this MSR challenge report, we focus in the case of the severity field. That field contains seven different levels of severity. Some of them seem very similar, and it is hard to distinguish among them. Users assign severity, and developers give priority to the reports depending on their severity. However, if users can not distinguish well among the various severity options, they will probably assign different priorities to bugs that require the same priority. We study the mean time to close bugs reported in Eclipse, and how the severity assigned by users affects this time. The results shows that classifying by time to close, there are less clusters of bugs than levels of severity. We therefore conclude that there is a need to make a simpler bug report form.},
	keywords = {bug fixing, bug report, bug tracking system, classification, eclipse, msr challenge, severity},
	isbn = {978-1-60558-024-1},
	doi = {http://doi.acm.org/10.1145/1370750.1370786},
	url = {http://doi.acm.org/10.1145/1370750.1370786},
	author = {Herraiz, Israel and Daniel M. German and Jesus M. Gonzalez-Barahona and Gregorio Robles}
}
@article {Barcellini:2008:UDM:1379919.1380288,
	title = {User and developer mediation in an Open Source Software community: Boundary spanning through cross participation in online discussions},
	journal = {Int. J. Hum.-Comput. Stud.},
	volume = {66},
	number = {7},
	year = {2008},
	pages = {558{\textendash}570},
	publisher = {Academic Press, Inc.},
	address = {Duluth, MN, USA},
	abstract = {The aim of this research is to analyse how design and use are mediated in Open Source Software (OSS) design. Focusing on the Python community, our study examines a {\textquoteright}{\textquoteright}pushed-by-users{\textquoteright}{\textquoteright} design proposal through the discussions occurring in two mailing-lists: one, user-oriented and the other, developer-oriented. To characterize the links between users and developers, we investigate the activities and references (knowledge sharing) performed by the contributors to these two mailing-lists. We found that the participation of users remains local to their community. However, several key participants act as boundary spanners between the user and the developer communities. This emerging role is characterized by cross-participation in parallel same-topic discussions in both mailing-lists, cohesion between cross-participants, the occupation of a central position in the social network linking users and developers, as well as active, distinctive and adapted contributions. The user championing the proposal acts as a key boundary spanner coordinating the process and using explicit linking strategies. We argue that OSS design may be considered as a form of {\textquoteright}{\textquoteright}role emerging design{\textquoteright}{\textquoteright}, i.e. design organized and pushed through emerging roles and through a balance between these roles. The OSS communities seem to provide a suitable socio-technical environment to enable such role emergence. },
	keywords = {Boundary spanners, Cross-participants, Distributed design, Open Source Software Community, Role emerging design},
	issn = {1071-5819},
	doi = {10.1016/j.ijhcs.2007.10.008},
	url = {http://dx.doi.org/10.1016/j.ijhcs.2007.10.008},
	author = {Barcellini, Flore and D{\'e}tienne, Fran{\c c}oise and Burkhardt, Jean-Marie}
}
@conference {1007,
	title = {Analysis of the Linux Kernel Evolution Using Code Clone Coverage},
	booktitle = {Fourth International Workshop on Mining Software Repositories (MSR{\textquoteright}07:ICSE Workshops 2007)},
	year = {2007},
	pages = {22 - 22},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Minneapolis, MN, USA},
	abstract = {Most studies of the evolution of software systems are based on the comparison of simple software metrics. In this paper, we present our preliminary investigation of the evolution of the Linux kernel using code-clone analysis and the code-clone coverage metrics. We examined 136 versions of the stable Linux kernel using a distributed extension of the code clone detection tool CCFinder. The result is shown as a heat map.},
	keywords = {ccfinder, clone, cloning, kernel, linux, metrics, source code},
	isbn = {0-7695-2950-X},
	doi = {10.1109/MSR.2007.1},
	attachments = {https://flosshub.org/sites/flosshub.org/files/28300022.pdf},
	author = {Livieri, Simone and Higo, Yoshiki and Matsushita, Makoto and Inoue, Katsuro}
}
@conference {996,
	title = {Correlating Social Interactions to Release History during Software Evolution},
	booktitle = {Fourth International Workshop on Mining Software Repositories (MSR{\textquoteright}07:ICSE Workshops 2007)},
	year = {2007},
	pages = {7 - 7},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Minneapolis, MN, USA},
	abstract = {In this paper, we propose a method to reason about the nature of software changes by mining and correlating discussion archives. We employ an information retrieval approach to find correlation between source code change history and history of social interactions surrounding these changes. We apply our correlation method on two software systems, LSEdit and Apache Ant. The results of these exploratory case studies demonstrate the evidence of similarity between the content of free-form text emails among developers and the actual modifications in the code. We identify a set of correlation patterns between discussion and changed code vocabularies and discover that some releases referred to as minor should instead fall under the major category. These patterns can be used to give estimations about the type of a change and time needed to implement it.},
	keywords = {ant, apache, change management, developers, discussion, effort estimation, lsedit, mailing lists, scm, source code},
	isbn = {0-7695-2950-X},
	doi = {10.1109/MSR.2007.4},
	attachments = {https://flosshub.org/sites/flosshub.org/files/28300007.pdf},
	author = {Baysal, Olga and Malton, Andrew J.}
}
@article {springerlink:10.1007/s10588-006-9006-3,
	title = {Correlating temporal communication patterns of the Eclipse open source community with performance and creativity},
	journal = {Computational \&amp; Mathematical Organization Theory},
	volume = {13},
	year = {2007},
	note = {"Social network data was collected from the Eclipse component development groups{\textquoteright} online mailing lists by using the online process tool (Gloor and Zhao, 2004). Data on bugs and enhancements for each group was collected from the Eclipse bugzilla database (Eclipse bugzilla, 2004). The social network data was analyzed with the TeCFlow tool (Gloor and Zhao, 2004)."
"The study is based on data from the three main projects of the Eclipse open source development community, namely {\textquotedblleft}eclipse{\textquotedblright}, {\textquotedblleft}tools{\textquotedblright} and {\textquotedblleft}technology{\textquotedblright}. We have chosen thirty-three different component development groups for analysis."
"The online process tool (online process tool, 2004) was utilized to collect communication data from their mailing list archives. The online process tool runs a robot that searches for URLs in the projects{\textquoteright} mailing list archives to compile a list of the possible URL links. It then extracts communication data as tuples in the form of {\textquotedblleft}sender, receiver, communication type, timestamp, communication contents{\textquotedblright} and stores it in the database. Further, bugs and enhancement data were collected from the Eclipse bugzilla database."},
	pages = {17-27},
	publisher = {Springer Netherlands},
	abstract = {This paper studies the temporal communication patterns of online communities of developers and users of the open source Eclipse Java development environment. It measures the productivity of each community and seeks to identify correlations that exist between group communication characteristics and productivity attributes. The study uses the TeCFlow (Temporal Communication Flow) visualizer to create movie maps of the knowledge flow by analyzing the publicly accessible Eclipse developer mailing lists as an approximation of the social networks of developers and users. Thirty-three different Eclipse communities discussing development and use of components of Eclipse such as the Java Development Tools, the different platform components, the C/C++ Development Tools and the AspectJ extension have been analyzed over a period of six months. The temporal evolution of social network variables such as betweenness centrality, density, contribution index, and degree have been computed and plotted. Productivity of each development group is measured in terms of two indices, namely performance and creativity. Performance of a group is defined as the ratio of new bugs submitted compared with bugs fixed within the same period of time. Creativity is calculated as a function of new features proposed and implemented. Preliminary results indicate that there is a correlation between attributes of social networks such as density and betweenness centrality and group productivity measures in an open source development community. We also find a positive correlation between changes over time in betweenness centrality and creativity, and a negative correlation between changes in betweenness centrality and performance.},
	keywords = {bug fixing, bugs, bugzilla, communication, creativity, developers, eclipse, email, email archives, feature requests, mailing lists, performance, productivity},
	issn = {1381-298X},
	url = {http://dx.doi.org/10.1007/s10588-006-9006-3},
	attachments = {https://flosshub.org/sites/flosshub.org/files/16.pdf},
	author = {Kidane, Yared and Gloor, Peter}
}
@conference {1011,
	title = {Detecting Patch Submission and Acceptance in OSS Projects},
	booktitle = {Fourth International Workshop on Mining Software Repositories (MSR{\textquoteright}07:ICSE Workshops 2007)},
	year = {2007},
	pages = {26 - 26},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Minneapolis, MN, USA},
	abstract = {The success of open source software (OSS) is completely dependent on the work of volunteers who contribute their time and talents. The submission of patches is the major way that participants outside of the core group of developers make contributions. We argue that the process of patch submission and acceptance into the codebase is an important piece of the open source puzzle and that the use of patch-related data can be helpful in understanding how OSS projects work. We present our methods in identifying the submission and acceptance of patches and give results and evaluation in applying these methods to the Apache webserver, Python interpreter, Postgres SQL database, and (with limitations) MySQL database projects. In addition, we present valuable ways in which this data has been and can be used.},
	keywords = {apache, contributions, mysql, patches, postgresql, python, scm, source code},
	isbn = {0-7695-2950-X},
	doi = {10.1109/MSR.2007.6},
	attachments = {https://flosshub.org/sites/flosshub.org/files/28300026.pdf},
	author = {Christian Bird and Gourley, Alex and Devanbu, Prem}
}
@conference {1003,
	title = {Evaluating the Harmfulness of Cloning: A Change Based Experiment},
	booktitle = {Fourth International Workshop on Mining Software Repositories (MSR{\textquoteright}07:ICSE Workshops 2007)},
	year = {2007},
	pages = {18 - 18},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Minneapolis, MN, USA},
	abstract = {Cloning is considered a harmful practice for software maintenance because it requires consistent changes of the entities that share a cloned fragment. However this claim has not been refuted or confirmed empirically. Therefore, we have developed a prototype tool, CloneTracker, in order to study the rate of change of applications containing clones. This paper describes CloneTracker and illustrates its preliminary application on a case study.},
	keywords = {ccfinder, clone, clones, clonetracker, cloning, ctags, cvs, dnsjava, maintenance, scm, source code},
	isbn = {0-7695-2950-X},
	doi = {10.1109/MSR.2007.8},
	author = {Lozano, Angela and Wermelinger, Michel and Nuseibeh, Bashar}
}
@conference {1017,
	title = {Forecasting the Number of Changes in Eclipse Using Time Series Analysis},
	booktitle = {Fourth International Workshop on Mining Software Repositories (MSR{\textquoteright}07:ICSE Workshops 2007)},
	year = {2007},
	pages = {32 - 32},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Minneapolis, MN, USA},
	abstract = {In order to predict the number of changes in the following months for the project Eclipse, we have applied a statistical (non-explanatory) model based on time series analysis. We have obtained the monthly number of changes in the CVS repository of Eclipse, using the CVSAnalY tool. The input to our model was the filtered series of the number of changes per month, and the output was the number of changes per month for the next three months. Then we aggregated the results of the three months to obtain the total number of changes in the given period in the challenge.},
	keywords = {change management, cvs, cvsanaly, eclipse, prediction},
	isbn = {0-7695-2950-X},
	doi = {10.1109/MSR.2007.10},
	attachments = {https://flosshub.org/sites/flosshub.org/files/28300032.pdf},
	author = {Herraiz, Israel and Jesus M. Gonzalez-Barahona and Gregorio Robles}
}
@conference {1001,
	title = {Identifying Changed Source Code Lines from Version Repositories},
	booktitle = {Fourth International Workshop on Mining Software Repositories (MSR{\textquoteright}07:ICSE Workshops 2007)},
	year = {2007},
	pages = {14 - 14},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Minneapolis, MN, USA},
	abstract = {Observing the evolution of software systems at different levels of granularity has been a key issue for a number of studies, aiming at predicting defects or at studying certain phenomena, such as the presence of clones or of crosscutting concerns. Versioning systems such as CVS and SVN, however, only provide information about lines added or deleted by a contributor: any change is shown as a sequence of additions and deletions. This provides an erroneous estimate of the amount of code changed.

This paper shows how the evolution of changes at source code line level can be inferred from CVS repositories, by combining information retrieval techniques and the Levenshtein edit distance. The application of the proposed approach to the ArgoUML case study indicates a high precision and recall.},
	keywords = {argouml, cvs, levenshtein, scm, source code},
	isbn = {0-7695-2950-X},
	doi = {10.1109/MSR.2007.14},
	attachments = {https://flosshub.org/sites/flosshub.org/files/28300014.pdf},
	author = {Canfora, Gerardo and Cerulo, Luigi and Di Penta, Massimiliano}
}
@conference {1013,
	title = {Impact of the Creation of the Mozilla Foundation in the Activity of Developers},
	booktitle = {Fourth International Workshop on Mining Software Repositories (MSR{\textquoteright}07:ICSE Workshops 2007)},
	year = {2007},
	pages = {28 - 28},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Minneapolis, MN, USA},
	abstract = {During 2003, the Mozilla project transitioned from company-promoted (sponsored by AOL) to community-promoted (sponsored by the Mozilla Foundation). What happened to the group of developers during this transition? There was any significant impact on its activity or composition? To answer these questions, we have performed an analysis of the CVS repository of Mozilla, using the CVSAnalY tool, finding little on activity, but dramatic changes in the the composition of the development team.},
	keywords = {cvs, cvsanaly, developers, mining challenge, mozilla, msr challenge, revision history},
	isbn = {0-7695-2950-X},
	doi = {10.1109/MSR.2007.15},
	attachments = {https://flosshub.org/sites/flosshub.org/files/28300028.pdf},
	author = {Jesus M. Gonzalez-Barahona and Gregorio Robles and Herraiz, Israel}
}
@proceedings {149,
	title = {Investigating success of open source software projects: A social network perspective},
	year = {2007},
	keywords = {CollectedOwnData NoShare},
	author = {Jing Wu and Khim-Yong Goh and Qian Tang}
}
@conference {997,
	title = {Mining CVS Repositories to Understand Open-Source Project Developer Roles},
	booktitle = {Fourth International Workshop on Mining Software Repositories (MSR{\textquoteright}07:ICSE Workshops 2007)},
	year = {2007},
	pages = {8 - 8},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Minneapolis, MN, USA},
	abstract = {This paper presents a model to represent the interactions of distributed open-source software developers and utilizes data mining techniques to derive developer roles. The model is then applied on case studies of two open-source projects, ORAC-DR and Mediawiki with encouraging results.},
	keywords = {cvs, developer interaction, developers, mediawiki, orac-dr, roles, scm, source code},
	isbn = {0-7695-2950-X},
	doi = {10.1109/MSR.2007.19},
	attachments = {https://flosshub.org/sites/flosshub.org/files/28300008.pdf},
	author = {Yu, Liguo and Ramaswamy, Srini}
}
@conference {1015,
	title = {Mining Eclipse Developer Contributions via Author-Topic Models},
	booktitle = {Fourth International Workshop on Mining Software Repositories (MSR{\textquoteright}07:ICSE Workshops 2007)},
	year = {2007},
	pages = {30 - 30},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Minneapolis, MN, USA},
	abstract = {We present the results of applying statistical author-topic models to a subset of the Eclipse 3.0 source code consisting of 2,119 source files and 700,000 lines of code from 59 developers. This technique provides an intuitive and automated framework with which to mine developer contributions and competencies from a given code base while simultaneously extracting software function in the form of topics. In addition to serving as a convenient summary for program function and developer activities, our study shows that topic models provide a meaningful, effective, and statistical basis for developer similarity analysis.},
	keywords = {contributions, developers, eclipse, expertise, mining challenge, msr challenge, source code, topics},
	isbn = {0-7695-2950-X},
	doi = {10.1109/MSR.2007.20},
	attachments = {https://flosshub.org/sites/flosshub.org/files/28300030.pdf},
	author = {Linstead, Erik and Rigor, Paul and Bajracharya, Sushil and Lopes, Cristina and Baldi, Pierre}
}
@conference {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}
}
@conference {995,
	title = {Open Borders? Immigration in Open Source Projects},
	booktitle = {Fourth International Workshop on Mining Software RepositoriesFourth International Workshop on Mining Software Repositories (MSR{\textquoteright}07:ICSE Workshops 2007)},
	year = {2007},
	pages = {6 - 6},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Minneapolis, MN, USA},
	abstract = {Open source software is built by teams of volunteers. Each project has a core team of developers, who have the authority to commit changes to the repository; this team is the elite, committed foundation of the project, selected through a meritocratic process from a larger number of people who participate on the mailing list. Most projects carefully regulate admission of outsiders to full developer privileges; some projects even have formal descriptions of this process. Understanding the factors that influence the "who, how and when" of this process is critical, both for the sustainability of FLOSS projects, and for outside stakeholders who want to gain entry and succeed. In this paper we mount a quantitative case study of the process by which people join FLOSS projects, using data mined from the Apache web server, Postgres, and Python. We develop a theory of open source project joining, and evaluate this theory based on our data.},
	keywords = {apache, core, joining, postgresql, python, team},
	isbn = {0-7695-2950-X},
	doi = {10.1109/MSR.2007.23},
	attachments = {https://flosshub.org/sites/flosshub.org/files/28300006.pdf},
	author = {Christian Bird and Gourley, Alex and Devanbu, Prem and Swaminathan, Anand and Hsu, Greta}
}
@article {1390,
	title = {An Open Source Approach to Developing Software in a Small Organization},
	journal = {IEEE Software},
	volume = {24},
	year = {2007},
	month = {01/2007},
	pages = {46 - 53},
	abstract = {This article is part of a special issue on Software Engineering Challenges in Small Software Organizations. The software development approach that developers at Kitware use borrows techniques from agile development and Extreme Programming and emphasizes long-term, ongoing projects. The company has used this approach on open source and closed-source projects in a wide range of sizes},
	keywords = {Cross-platform, Small-business, software engineering, Software testing},
	issn = {0740-7459},
	doi = {10.1109/MS.2007.5},
	author = {Martin, Ken and Hoffman, Bill}
}
@article {springerlink:10.1007/s10368-007-0086-4,
	title = {Open source software: Motivation and restrictive licensing},
	journal = {International Economics and Economic Policy},
	volume = {4},
	year = {2007},
	note = {"We employ a unique data set consisting of 71 open source projects hosted at the SourceForge web site. The 71 projects in the sample were chosen (in January 2000)"
"This sample was observed over an 18-month period from January 2002 through the middle of 2003, with data collected at 2-month intervals."
"We are grateful to NERA for providing us with the data."
"Although we only have data on a relatively small sample of the projects hosted SourceForge, the sample is unique because of data on lines of code as well as data on different versions of the program. The latter is a potentially important control variable, since a change in version may necessitate additional lines of code.
Our data set contains information on the size of the open source projects in the form of source lines of code (SLOC). Using SLOC as a performance measure is not always ideal; nevertheless, this performance measure is employed in the profession and the literature.15 For our purposes, SLOC is in fact an ideal measure, because we want to measure the effort that is put into the project, rather than whether a project succeeds."
},
	pages = {209-225},
	publisher = {Springer Berlin / Heidelberg},
	abstract = {Open source software (OSS) is an economic paradox. Development of open source software is often done by unpaid volunteers and the source code is typically freely available. Surveys suggest that status, signaling, and intrinsic motivations play an important role in inducing developers to invest effort. Contribution to an OSS project is rewarded by adding one{\textquoteright}s name to the list of contributors which is publicly observable. Such incentives imply that programmers may have little incentive to contribute beyond the threshold level required for being listed as a contributor. Using a unique data set we empirically examine this hypothesis. We find that the output per contributor in open source projects is much higher when licenses are less restrictive and more commercially oriented. These results indeed suggest a status, signaling, or intrinsic motivation for participation in OSS projects with restrictive licenses.},
	keywords = {contributions, contributors, developers, incentives, license analysis, licenses, lines of code, loc, MOTIVATION, restrictive, scm, size, status, version history},
	issn = {1612-4804},
	url = {http://dx.doi.org/10.1007/s10368-007-0086-4},
	author = {Fershtman, Chaim and Gandal, Neil}
}
@conference {1014,
	title = {Predicting Eclipse Bug Lifetimes},
	booktitle = {Fourth International Workshop on Mining Software RepositoriesFourth International Workshop on Mining Software Repositories (MSR{\textquoteright}07:ICSE Workshops 2007)},
	year = {2007},
	pages = {29 - 29},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Minneapolis, MN, USA},
	abstract = {In non-trivial software development projects planning and allocation of resources is an important and difficult task. Estimation of work time to fix a bug is commonly used to support this process. This research explores the viability of using data mining tools to predict the time to fix a bug given only the basic information known at the beginning of a bug{\textquoteright}s lifetime. To address this question, a historical portion of the Eclipse Bugzilla database is used for modeling and predicting bug lifetimes. A bug history transformation process is described and several data mining models are built and tested. Interesting behaviours derived from the models are documented. The models can correctly predict up to 34.9\% of the bugs into a discretized log scaled lifetime class.},
	keywords = {bug fixing, bugzilla, classification, eclipse, effort estimation, mining challenge, msr challenge, prediction, weka},
	isbn = {0-7695-2950-X},
	doi = {10.1109/MSR.2007.25},
	attachments = {https://flosshub.org/sites/flosshub.org/files/28300029.pdf},
	author = {Panjer, Lucas D.}
}
@conference {1012,
	title = {Prioritizing Warning Categories by Analyzing Software History},
	booktitle = {Fourth International Workshop on Mining Software Repositories (MSR{\textquoteright}07:ICSE Workshops 2007)},
	year = {2007},
	pages = {27 - 27},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Minneapolis, MN, USA},
	abstract = {Automatic bug finding tools tend to have high false positive rates: most warnings do not indicate real bugs. Usually bug finding tools prioritize each warning category. For example, the priority of "overflow" is 1 and the priority of "jumbled incremental" is 3, but the tools{\textquoteright} prioritization is not very effective.

In this paper, we prioritize warning categories by analyzing the software change history. The underlying intuition is that if warnings from a category are resolved quickly by developers, the warnings in the category are important. Experiments with three bug finding tools (FindBugs, JLint, and PMD) and two open source projects (Columba and jEdit) indicate that different warning categories have very different lifetimes. Based on that observation, we propose a preliminary algorithm for warning category prioritizing.},
	keywords = {bug fixing, change history, columba, findbugs, jedit, jlint, kenyon, pmd, warning},
	isbn = {0-7695-2950-X},
	doi = {10.1109/MSR.2007.26},
	attachments = {https://flosshub.org/sites/flosshub.org/files/28300027.pdf},
	author = {Kim, Sunghun and Ernst, Michael D.}
}
@conference {1225,
	title = {Programming Language Trends in Open Source Development: An Evaluation Using Data from All Production Phase SourceForge Projects},
	booktitle = {2nd Workshop on Public Data about Software Development (WoPDaSD 2007)},
	year = {2007},
	note = {"Our data were gathered from the SourceForge Research Ar- chive (SFRA) [4] and the CVS repositories Open Source projects hosted on SourceForge. We used cvs2mysql and SFRA+ to collect the data. cvs2mysql gathers data from CVS repositories and writes them to SQL scripts for im- port into a MySQL 5.0 database. The data collected by cvs2mysql are the name of the file, the location of the file in the repository, the type and state of the file, as well as the author, date, number of lines added and removed, and the author{\textquoteright}s message for each revision to the file."},
	abstract = {In this work, we analyze data collected from the CVS repos- itories of 9,997 Open Source projects hosted on SourceForge in an effort to understand trends in programming language usage in the Open Source community between 2000 and 2005. The trends we consider include: 1) the relative popularity of the ten most popular programming languages over time, 2) the use of multiple programming languages by individual programmers and by individual projects, and 3) the programming languages most often used in combination.},
	keywords = {cvs, cvs2mysql, programming languages, sfra, sourceforge, srda},
	attachments = {https://flosshub.org/sites/flosshub.org/files/Delorey2007b.pdf},
	author = {Delorey, Daniel P. and Knutson, Charles D. and Giraud-Carrier, C.}
}
@conference {1004,
	title = {Release Pattern Discovery via Partitioning: Methodology and Case Study},
	booktitle = {Fourth International Workshop on Mining Software Repositories (MSR{\textquoteright}07:ICSE Workshops 2007)},
	year = {2007},
	pages = {19 - 19},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Minneapolis, MN, USA},
	abstract = {The development of Open Source systems produces a variety of software artifacts such as source code, version control records, bug reports, and email discussions. Since the development is distributed across different tool environments and developer practices, any analysis of project behavior must be inferred from whatever common artifacts happen to be available. In this paper, we propose an approach to characterizing a project{\textquoteright}s behavior around the time of major and minor releases; we do this by partitioning the observed activities, such as artifact check-ins, around the dates of major and minor releases, and then look for recognizable patterns. We validate this approach by means of a case study on the MySQL database system; in this case study, we found patterns which suggested MySQL was behaving consistently within itself. These patterns included testing and documenting that took place more before a release than after and that the rate of source code changes dipped around release time.},
	keywords = {bitkeeper, bt2csv, cvs, evolution, mysql, releases, revision history, scm, softchange, version control},
	isbn = {0-7695-2950-X},
	doi = {10.1109/MSR.2007.28},
	attachments = {https://flosshub.org/sites/flosshub.org/files/28300019.pdf},
	author = {Hindle, Abram and Godfrey, Michael W. and Holt, Richard C.}
}
@article {flosswp405,
	title = {Self-organization of teams for free/libre open source software development},
	journal = {Information and Software Technology Journal},
	volume = {49},
	number = {564-575},
	year = {2007},
	note = {"First, the data from these projects that we needed for analysis had to be publicly available (ruling out projects that limit access to their email lists or trackers). Second, we chose the projects that had more than 7 members"..."projects that have attracted numerous developers beyond the initial project founders, are continuing to release software, have numerous downloads and have an active user community that provides feedback"
"3 FLOSS projects were selected for analysis, namely Gaim, eGroupWare and Compiere ERP."

all had sourceforge hosting

Data: "The primary data used for our study were interactions on the main developer communication forum, either a developer mailing list or web-based discussion forum."

Analysis: "For this project, we inductively content-analyzed developer email interactions to identify the task assignment mechanisms used in the process. We coded each instance of task assignment identified on three dimensions: who assigned the task, to whom, and how"
},
	abstract = {This paper provides empirical evidence about how free/libre open source software development teams self-organize their work. Following a case study methodology, we examined developer interaction data from three active and successful FLOSS projects using qualitative research methods, specifically inductive content analysis, to identify the task-assignment mechanisms used by the participants. We found that "self-assignment" was the most common mechanism across three FLOSS projects. This mechanism is consistent with expectations for distributed and largely volunteer teams. We conclude by discussing whether these emergent practices can be usefully transferred to mainstream practice and indicating directions for future research.},
	keywords = {case study, compiere, coordination, DESIGN, distributed teams, egroupware, email, email archives, forum, free/libre open source software development, gaim, INTERNET, mailing list, metadata, qualitative research methods, self-organizing teams, sourceforge, SYSTEMS, task assignment, WORK},
	attachments = {https://flosshub.org/sites/flosshub.org/files/task_assignment_final.pdf},
	author = {Kevin Crowston and Li, Qing and Kangning Wei and Eseryel, U. Yeliz and Howison, James}
}
@article {119,
	title = {Social network structures in open source software development teams},
	journal = {Journal of Database Management},
	volume = {18},
	number = {2},
	year = {2007},
	note = {"Three projects were selected from SourceForge.net in terms of their similarities as well as their differences. Monthly data were extracted from the bug tracking systems in order to achieve a longitudinal view of the interaction pattern of each project. Social network analysis was used to generate the indices of social structure."

no pdf},
	month = {Apr-Jun},
	pages = {25-40},
	abstract = {Drawing on social network theories and previous studies, this research examines the dynamics of social network structures in open source software (OSS) teams. Three projects were selected from SourceForge.net in terms of their similarities as well as their differences. Monthly data were extracted from the bug tracking systems in order to achieve a longitudinal view of the interaction pattern of each project. Social network analysis was used to generate the indices of social structure. The finding suggests that the interaction pattern of OSS projects evolves from a single hub at the beginning to a corel periphery model as the projects move forward.},
	keywords = {bug tracking, bugs, COMMUNITY, INNOVATION, longitudinal study, MODEL, open source, social, social network analysis, social networks, sourceforge, structure},
	isbn = {1063-8016},
	author = {Long, Y. and Siau, K.}
}
@conference {993,
	title = {Spam Filter Based Approach for Finding Fault-Prone Software Modules},
	booktitle = {Fourth International Workshop on Mining Software Repositories (MSR{\textquoteright}07:ICSE Workshops 2007)},
	year = {2007},
	pages = {4 - 4},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Minneapolis, MN, USA},
	abstract = {Because of the increase of needs for spam e-mail detection, the spam filtering technique has been improved as a convenient and effective technique for text mining. We propose a novel approach to detect fault-prone modules in a way that the source code modules are considered as text files and are applied to the spam filter directly. In order to show the applicability of our approach, we conducted experimental applications using source code repositories of Java based open source developments. The result of experiments shows that our approach can classify more than 75\% of software modules correctly.},
	keywords = {argouml, bug reports, classification, eclipse, java, modules, scm, spam, text mining},
	isbn = {0-7695-2950-X},
	doi = {10.1109/MSR.2007.29},
	attachments = {https://flosshub.org/sites/flosshub.org/files/28300004.pdf},
	author = {Mizuno, Osamu and Ikami, Shiro and Nakaichi, Shuya and Kikuno, Tohru}
}
@conference {1002,
	title = {Studying Versioning Information to Understand Inheritance Hierarchy Changes},
	booktitle = {Fourth International Workshop on Mining Software Repositories (MSR{\textquoteright}07:ICSE Workshops 2007)},
	year = {2007},
	pages = {16 - 16},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Minneapolis, MN, USA},
	abstract = {With the widespread adoption of object-oriented programming, changing the inheritance hierarchy became an inherent part of today{\textquoteright}s software maintenance activities. Unfortunately, little is known about the "state-of-the-practice" with respect to changing an application{\textquoteright}s inheritance hierarchy, and consequently we do not know how the change process can be improved. In this paper, we report on a study of the hierarchy changes stored in a versioning system to explore the answers to three research questions: (1) why are hierarchy changes made? (2) what kind of hierarchy changes are made? (3) what is the impact of these changes? Based on the results of this study, we formulate 7 hypotheses which should be investigated further to make conclusive interpretations on how hierarchy changes fit in the actual change process.},
	keywords = {argouml, change management, inheritance, jedit},
	isbn = {0-7695-2950-X},
	doi = {10.1109/MSR.2007.30},
	attachments = {https://flosshub.org/sites/flosshub.org/files/28300016.pdf},
	author = {Rysselberghe, Filip Van and Demeyer, Serge}
}
@conference {1006,
	title = {Towards a Theoretical Model for Software Growth},
	booktitle = {Fourth International Workshop on Mining Software Repositories (MSR{\textquoteright}07:ICSE Workshops 2007)},
	year = {2007},
	pages = {21 - 21},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Minneapolis, MN, USA},
	abstract = {Software growth (and more broadly, software evolution) is usually considered in terms of size or complexity of source code. However in different studies, usually different metrics are used, which make it difficult to compare approaches and results. In addition, not all metrics are equally easy to calculate for a given source code, which leads to the question of which one is the easiest to calculate without losing too much information. To address both issues, in this paper present a comprehensive study, based on the analysis of about 700,000 C source code files, calculating several size and complexity metrics for all of them. For this sample, we have found double Pareto statistical distributions for all metrics considered, and a high correlation between any two of them. This would imply that any model addressing software growth should produce this Pareto distributions, and that analysis based on any of the considered metrics should show a similar pattern, provided the sample of files considered is large enough.},
	keywords = {C, complexity, evolution, freebsd, growth, halstead, lines of code, loc, mccabe, metrics, scm, size, sloc, sloccount, source code},
	isbn = {0-7695-2950-X},
	doi = {10.1109/MSR.2007.31},
	attachments = {https://flosshub.org/sites/flosshub.org/files/28300021.pdf},
	author = {Herraiz, Israel and Jesus M. Gonzalez-Barahona and Gregorio Robles}
}
@conference {1226,
	title = {Understanding the KDE Social Structure through Mining of Email Archive},
	booktitle = {2nd Workshop on Public Data about Software Development (WoPDaSD 2007)},
	year = {2007},
	note = {"Our data source is constituted by e-mails sent to KDE mailing-lists and archived by MARC"

"Two problems quickly arise: neither the e-mails addresses nor the names can be considered unique. Consequently, we used an in-depth search algorithm to put together {\textquotedblleft}name-email{\textquotedblright} couples corresponding to a same contributor. Indeed, the algorithm suggests possible merges."

"There is a specific mailing list in our data set, kde-commit, which gathers automatic notifications from the revision control system (RCS)....We measure {\textquotedblleft}commit{\textquotedblright} by the number of messages sent to the {\textquotedblleft}kde-commit{\textquotedblright} mailing list. However, we did not count {\textquotedblleft}silent{\textquotedblright} commits, nor usual messages sent to this mailing list."

"We measured activities done in BTS in two ways: {\textquotedblleft}bug opener{\textquotedblright} and {\textquotedblleft}non bug opener{\textquotedblright}.	First, we counted the number of modifications done by the contributor who opened the concerned bug report. "
},
	abstract = {In order to achieve a better understanding of FLOSS social structure, we need a definition of social position. From a theoretical perspective, we propose to think the participation as a trajectory. Empirically, we use optimal matching to build a typology of participation trajectories based on KDE email archives. We show how these trajectories structure the community as a whole by combining these results with a social network analysis.},
	keywords = {bug tracking system, bugzilla, commit, email, email archive, kde, mailing list, participation, revision control, social network analysis},
	attachments = {https://flosshub.org/sites/flosshub.org/files/wopdasd_studer_et_all_full.pdf},
	author = {Studer, Matthias and M{\"u}ller, Beno{\^\i}t and Ritschard, Gilbert}
}
@conference {998,
	title = {Visual Data Mining in Software Archives to Detect How Developers Work Together},
	booktitle = {Fourth International Workshop on Mining Software RepositoriesFourth International Workshop on Mining Software Repositories (MSR{\textquoteright}07:ICSE Workshops 2007)},
	year = {2007},
	pages = {9 - 9},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Minneapolis, MN, USA},
	abstract = {Analyzing the check-in information of open source software projects which use a version control system such as CVS or SUBVERSION can yield interesting and important insights into the programming behavior of developers. As in every major project tasks are assigned to many developers, the development must be coordinated between these programmers.

This paper describes three visualization techniques that help to examine how programmers work together, e.g. if they work as a team or if they develop their part of the software separate from each other. Furthermore, phases of stagnation in the lifetime of a project can be uncovered and thus, possible problems are revealed.

To demonstrate the usefulness of these visualization techniques we performed case studies on two open source projects. In these studies interesting patterns of developers? behavior, e.g. the specialization on a certain module can be observed. Moreover, modules that have been changed by many developers can be identified as well as such ones that have been altered by only one programmer.},
	keywords = {change, coordination, cvs, developers, junit, modules, scm, source code, svn, teams, tomcat, visualization},
	isbn = {0-7695-2950-X},
	doi = {10.1109/MSR.2007.34},
	attachments = {https://flosshub.org/sites/flosshub.org/files/28300009.pdf},
	author = {Weissgerber, Peter and Pohl, Mathias and Burch, Michael}
}
@article {120,
	title = {Applying Social Network Analysis Techniques to Community-Driven Libre Software Projects},
	journal = {International Journal of Information Technology and Web Engineering},
	volume = {1},
	number = {3},
	year = {2006},
	abstract = {Source code management repositories of large, long-lived libre (free, open source) software projects can be a source of valuable data about the organizational structure, evolution, and knowledge exchange in the corresponding development communities. Unfortunately, the sheer volume of the available information renders it almost unusable without applying methodologies which highlight the relevant information for a given aspect of the project. Such methodology is proposed in this article, based on well known concepts from the social networks analysis field, which can be used to study the relationships among developers and how they collaborate in different parts of a project. It is also applied to data mined from some well known projects (Apache, GNOME, and KDE), focusing on the characterization of their collaboration network architecture. These cases help to understand the potentials of the methodology and how it is applied, but also shows some relevant results which open new paths in the understanding of the informal organization of libre software development communities.},
	keywords = {apache, conway{\textquoteright}s law, cvs, gnome, kde, scm, social network analysis, source code},
	attachments = {https://flosshub.org/sites/flosshub.org/files/06_Lopez_ijitwe_sna.pdf},
	author = {L{\'o}pez-Fern{\'a}ndez, L. and Gregorio Robles and Jesus M. Gonzalez-Barahona and Herraiz, I.}
}
@conference {D{\textquoteright}Ambros:2006:AER:1137983.1138029,
	title = {Applying the evolution radar to PostgreSQL},
	booktitle = {Proceedings of the 2006 international workshop on Mining software repositories},
	series = {MSR {\textquoteright}06},
	year = {2006},
	pages = {177{\textendash}178},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	keywords = {cvs, documentation, evolution, evolution radar, logical coupling, makefile, mining challenge, msr challenge, postgresql, re-engineering, refactoring, release history, rhdb, source code, version control, visualization},
	isbn = {1-59593-397-2},
	doi = {http://doi.acm.org/10.1145/1137983.1138029},
	url = {http://doi.acm.org/10.1145/1137983.1138029},
	attachments = {https://flosshub.org/sites/flosshub.org/files/177ApplyingEvolution.pdf},
	author = {D{\textquoteright}Ambros, Marco and Lanza, Michele}
}
@conference {WeiBgerber:2006:RLE:1137983.1138011,
	title = {Are refactorings less error-prone than other changes?},
	booktitle = {Proceedings of the 2006 international workshop on Mining software repositories},
	series = {MSR {\textquoteright}06},
	year = {2006},
	pages = {112{\textendash}118},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {Refactorings are program transformations which should preserve the program behavior. Consequently, we expect that during phases when there are mostly refactorings in the change history of a system, only few new bugs are introduced. For our case study we analyzed the version histories of several open source systems and reconstructed the refactorings performed. Furthermore, we obtained bug reports from various sources depending on the system. Based on this data we identify phases when the above hypothesis holds and those when it doesn{\textquoteright}t.},
	keywords = {argouml, bug reports, bugs, change history, jedit, junit, re-engineering, refactoring, reverse engineering, software evolution, version control},
	isbn = {1-59593-397-2},
	doi = {http://doi.acm.org/10.1145/1137983.1138011},
	url = {http://doi.acm.org/10.1145/1137983.1138011},
	attachments = {https://flosshub.org/sites/flosshub.org/files/112AreRefactorings.pdf},
	author = {Wei{\ss}gerber, Peter and Diehl, Stephan}
}
@conference {Gurbani:2006:CSC:1134285.1134352,
	title = {A case study of a corporate open source development model},
	booktitle = {Proceedings of the 28th international conference on Software engineering},
	series = {ICSE {\textquoteright}06},
	year = {2006},
	pages = {472{\textendash}481},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {Open source practices and tools have proven to be highly effective for overcoming the many problems of geographically distributed software development. We know relatively little, however, about the range of settings in which they work. In particular, can corporations use the open source development model effectively for software projects inside the corporate domain? Or are these tools and practices incompatible with development environments, management practices, and market-driven schedule and feature decisions typical of a commercial software house? We present a case study of open source software development methodology adopted by a significant commercial software project in the telecommunications domain. We extract a number of lessons learned from the experience, and identify open research questions.},
	keywords = {architecture, case study, open source, session initiation protocol, software development, vkg},
	isbn = {1-59593-375-1},
	doi = {10.1145/1134285.1134352},
	url = {http://doi.acm.org/10.1145/1134285.1134352},
	author = {Gurbani, Vijay K. and Garvert, Anita and Herbsleb, James D.}
}
@conference {Beyer:2006:CVA:1137983.1138023,
	title = {Co-change visualization applied to PostgreSQL and ArgoUML: (MSR challenge report)},
	booktitle = {Proceedings of the 2006 international workshop on Mining software repositories},
	series = {MSR {\textquoteright}06},
	year = {2006},
	pages = {165{\textendash}166},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {Co-change visualization is a method to recover the subsystem structure of a software system from the version history, based on common changes and visual clustering. This paper presents the results of applying the tool CCVisu which implements co-change visualization, to the two open-source software systems PostgreSQL and ArgoUML The input of the method is the co-change graph, which can be easily extracted by CCVisu from a Cvs version repository. The output is a graph layout that places software artifacts that were often commonly changed at close positions, and artifacts that were rarely co-changed at distant positions. This property of the layout is due to the clustering property of the underlying energy model,which evaluates the quality of a produced layout. The layout can be displayed on the screen, or saved to a file in SVG or VRML format.},
	keywords = {argouml, ccvisu, cvs, force-directed graph layout, graph, mining challenge, msr challenge, postgresql, software clustering, software structure analysis, software visualization, version control, visualization},
	isbn = {1-59593-397-2},
	doi = {http://doi.acm.org/10.1145/1137983.1138023},
	url = {http://doi.acm.org/10.1145/1137983.1138023},
	attachments = {https://flosshub.org/sites/flosshub.org/files/165Co-Change.pdf},
	author = {Beyer, Dirk}
}
@conference {682,
	title = {Collaborative Maintenance in Large Open-Source Projects},
	booktitle = {OSS2006: Open Source Systems (IFIP 2.13)},
	series = {IFIP International Federation for Information Processing},
	year = {2006},
	pages = {233 - 244},
	publisher = {Springer},
	organization = {Springer},
	abstract = {The paper investigates collaborative work among maintainers of open source software by analyzing the logs of a set of 10 large projects. We inquire whether teamwork can be influenced by several characteristics of code. Preliminary results suggest that collaboration among maintainers in most large open-source projects seems to be positively influenced by file vintage and by Halstead volume of files, and negatively by McCabe complexity and size measured in SLOCs. These results could be consistent with an increased attractivity of files created early in the history of a project, and with maintainers being less attracted by more verbose code and by more complex code, although in this last case it might also reflect the fact that more complex files would be de facto more exclusive in terms of maintenance.
},
	keywords = {apache, COLLABORATION, complexity, cvs, gaim, gcc, ghostscript, halstead, lines of code, loc, mccabe, mozilla, netbsd, openssh, postgresql, python, sloc},
	doi = {http://dx.doi.org/10.1007/0-387-34226-5_23},
	attachments = {https://flosshub.org/sites/flosshub.org/files/Collaborative\%20Maintenance.pdf},
	author = {den Besten, Matthijs and Jean-Michel Dalle and Galia, Fabrice}
}
@conference {683,
	title = {Communication Networks in an Open Source Software Project},
	booktitle = {OSS2006: Open Source Systems (IFIP 2.13)},
	series = {IFIP International Federation for Information Processing },
	volume = {203/2006},
	year = {2006},
	month = {2006///},
	pages = {297 - 306},
	publisher = {Springer},
	organization = {Springer},
	abstract = {This study explores the nature of the social network and the patterns of communication that exist in an open source software development project, the Apache HTTP (WEB) server project. Our analysis of archival data on email communications between developers in the Apache HTTP server project suggests an interesting pattern of communication. We find that the core developers self-organize into three sub-groups that communicate intensely in completing the project. Our analysis also reveals that a few prominent developers who are centrally located in the network are driving communications within the project. We identify the implications of our findings and suggest areas for further research.
},
	keywords = {apache, core, developers, email, email archive, mailing list, participation, social network analysis},
	issn = {978-0-387-34225-2},
	doi = {http://dx.doi.org/10.1007/0-387-34226-5_30},
	attachments = {https://flosshub.org/sites/flosshub.org/files/Communication\%20Networks\%20in\%20an\%20Open\%20Source.pdf},
	author = {Roberts, Jeffrey and Il-Horn Hann and Sandra Slaughter}
}
@conference {686,
	title = {Contributor Turnover in Libre Software Projects},
	booktitle = {OSS2006: Open Source Systems (IFIP 2.13)},
	series = {IFIP International Federation for Information Processing},
	year = {2006},
	pages = {273 - 286},
	publisher = {Springer},
	organization = {Springer},
	abstract = {A common problem that management faces in software companies is the high instability of their staff. In libre (free, open source) software projects, the permanence of developers is also an open issue, with the potential of causing problems amplified by the self-organizing nature that most of them exhibit. Hence, human resources in libre software projects are even more difficult to manage: developers are in most cases not bound by a contract and, in addition, there is not a real management structure concerned about this problem. This raises some interesting questions with respect to the composition of development teams in libre software projects, and how they evolve over time. There are projects lead by their original founders (some sort of {\textquotedblleft}code gods{\textquotedblright}), while others are driven by several different developer groups over time (i.e. the project {\textquotedblleft}regenerates{\textquotedblright} itself). 
In this paper, we propose a quantitative methodology, based on the analysis of the activity in the source code management repositories, to study how these processes (developers leaving, developers joining) affect libre software projects. The basis of it is the analysis of the composition of the core group, the group of developers most active in a project, for several time lapses. We will apply this methodology to several large, well-known libre software projects, and show how it can be used to characterize them. In addition, we will discuss the lessons that can be learned, and the validity of our proposal.
},
	keywords = {apache, committers, core, cvs, cvsanaly, developers, evolution, freebsd, gimp, gnome, kde, mono, mozilla},
	doi = {http://dx.doi.org/10.1007/0-387-34226-5_28},
	attachments = {https://flosshub.org/sites/flosshub.org/files/Contributor\%20Turnover\%20in\%20Libre\%20Software\%20Projects.pdf},
	author = {Gregorio Robles and Gonzalez-Barahona, Jesus}
}
@article {90,
	title = {Core and periphery in Free/Libre and Open Source software team communications},
	journal = {Proceedings of the 39th Annual Hawaii International Conference on System Sciences-Volume 06},
	year = {2006},
	abstract = {The concept of the core group of developers is important and often discussed in empirical studies of FLOSS projects. This paper examines the question, "how does one empirically distinguish the core?" Being able to identify the core members of a FLOSS development project is important because many of the processes necessary for successful projects likely involve core members differently than peripheral members, so analyses that mix the two groups will likely yield invalid results. 

We compare 3 analysis approaches to identify the core: the named list of developers, a Bradford{\textquoteright}s law analysis that takes as the core the most frequent contributors and a social network analysis of the interaction pattern that identifies the core in a core-and-periphery structure. We apply these measures to the interactions around bug fixing for 116 SourceForge projects. The 3 techniques identify different individuals as core members; examination of which individuals are identified leads to suggestions for refining the measures. All 3 measures though suggest that the core of FLOSS projects is a small fraction of the total number of contributors.},
	keywords = {bug fixing, contributions, contributors, core, developers, social network analysis, sourceforge, team},
	author = {Kevin Crowston and Kangning Wei and Li, Qing and Howison, James}
}
@conference {Sager:2006:DSJ:1137983.1138000,
	title = {Detecting similar Java classes using tree algorithms},
	booktitle = {Proceedings of the 2006 international workshop on Mining software repositories},
	series = {MSR {\textquoteright}06},
	year = {2006},
	pages = {65{\textendash}71},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {Similarity analysis of source code is helpful during development to provide, for instance, better support for code reuse. Consider a development environment that analyzes code while typing and that suggests similar code examples or existing implementations from a source code repository. Mining software repositories by means of similarity measures enables and enforces reusing existing code and reduces the developing effort needed by creating a shared knowledge base of code fragments. In information retrieval similarity measures are often used to find documents similar to a given query document. This paper extends this idea to source code repositories. It introduces our approach to detect similar Java classes in software projects using tree similarity algorithms. We show how our approach allows to find similar Java classes based on an evaluation of three tree-based similarity measures in the context of five user-defined test cases as well as a preliminary software evolution analysis of a medium-sized Java project. Initial results of our technique indicate that it (1) is indeed useful to identify similar Java classes, (2)successfully identifies the ex ante and ex post versions of refactored classes, and (3) provides some interesting insights into within-version and between-version dependencies of classes within a Java project.},
	keywords = {change analysis, clones, coogle, eclipse, famix, java, similarity, software evolution, software repositories, source code, tree similarity measures},
	isbn = {1-59593-397-2},
	doi = {http://doi.acm.org/10.1145/1137983.1138000},
	url = {http://doi.acm.org/10.1145/1137983.1138000},
	attachments = {https://flosshub.org/sites/flosshub.org/files/65Detecting.pdf},
	author = {Sager, Tobias and Bernstein, Abraham and Pinzger, Martin and Kiefer, Christoph}
}
@conference {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 {D{\textquoteright}Ambros:2006:ERV:1137983.1137992,
	title = {The evolution radar: visualizing integrated logical coupling information},
	booktitle = {Proceedings of the 2006 international workshop on Mining software repositories},
	series = {MSR {\textquoteright}06},
	year = {2006},
	pages = {26{\textendash}32},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {In software evolution research logical coupling has extensively been used to recover the hidden dependencies between source code artifacts. They would otherwise go lost because of the file-based nature of current versioning systems. Previous research has dealt with low-level couplings between files, leading to an explosion of data to be analyzed, or has abstracted the logical couplings to module level, leading to a loss of detailed information. In this paper we propose a visualization-based approach which integrates both file-level and module-level logical coupling information. This not only facilitates an in-depth analysis of the logical couplings at all granularity levels, it also leads to a precise characterization of the system modules in terms of their logical coupling dependencies.},
	keywords = {change management, cvs, evolution, logical coupling, mozilla, scm, source code, thunderbird, tinderbox, visualization},
	isbn = {1-59593-397-2},
	doi = {http://doi.acm.org/10.1145/1137983.1137992},
	url = {http://doi.acm.org/10.1145/1137983.1137992},
	attachments = {https://flosshub.org/sites/flosshub.org/files/26TheEvolutionRadar.pdf},
	author = {D{\textquoteright}Ambros, Marco and Lanza, Michele and Lungu, Mircea}
}
@conference {Jiang:2006:EEC:1137983.1138030,
	title = {Examining the evolution of code comments in PostgreSQL},
	booktitle = {Proceedings of the 2006 international workshop on Mining software repositories},
	series = {MSR {\textquoteright}06},
	year = {2006},
	pages = {179{\textendash}180},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {It is common, especially in large software systems, for developers to change code without updating its associated comments due to their unfamiliarity with the code or due to time constraints. This is a potential problem since outdated comments may confuse or mislead developers who perform future development. Using data recovered from CVS, we study the evolution of code comments in the PostgreSQL project. Our study reveals that over time the percentage of commented functions remains constant except for early fluctuation due to the commenting style of a particular active developer.},
	keywords = {code comments, comments, cvs, evolution, functions, maintenance, mining challenge, msr challenge, postgresql, software evolution, software maintenance, source code},
	isbn = {1-59593-397-2},
	doi = {http://doi.acm.org/10.1145/1137983.1138030},
	url = {http://doi.acm.org/10.1145/1137983.1138030},
	attachments = {https://flosshub.org/sites/flosshub.org/files/179ExaminingTheEvolution.pdf},
	author = {Zhen Ming Jiang and Hassan, Ahmed E.}
}
@conference {Canfora:2006:FGI:1137983.1138009,
	title = {Fine grained indexing of software repositories to support impact analysis},
	booktitle = {Proceedings of the 2006 international workshop on Mining software repositories},
	series = {MSR {\textquoteright}06},
	year = {2006},
	pages = {105{\textendash}111},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {Versioned and bug-tracked software systems provide a huge amount of historical data regarding source code changes and issues management. In this paper we deal with impact analysis of a change request and show that data stored in software repositories are a good descriptor on how past change requests have been resolved. A fine grained analysis method of software repositories is used to index code at different levels of granularity, such as lines of code and source files, with free text contained in software repositories. The method exploits information retrieval algorithms to link the change request description and code entities impacted by similar past change requests. We evaluate such approach on a set of three open-source projects.},
	keywords = {argouml, change analysis, Firefox, gedit, impact analysis, mining software repositories, scm, source code, version control},
	isbn = {1-59593-397-2},
	doi = {http://doi.acm.org/10.1145/1137983.1138009},
	url = {http://doi.acm.org/10.1145/1137983.1138009},
	attachments = {https://flosshub.org/sites/flosshub.org/files/105FineGrained.pdf},
	author = {Canfora, Gerardo and Cerulo, Luigi}
}
@conference {691,
	title = {From Individual Contribution to Group Learning},
	booktitle = {OSS2006: Open Source Systems (IFIP 2.13)},
	series = {IFIP International Federation for Information Processing},
	year = {2006},
	pages = {77 - 90},
	publisher = {Springer},
	organization = {Springer},
	abstract = {Open Source Software (OSS) groups experience many benefits and challenges with respect to the core group{\textquoteright}s effectiveness. In order to capitalize on the benefits and minimize the challenges, OSS groups must learn not only on the individual level, but also on the group level. OSS groups learn by integrating individual contributions into the group{\textquoteright}s product and processes.
This paper reports on the characteristics of the learning process in OSS groups. The study utilized an embedded single case study design that observed and analyzed group learning processes in the Apache Web server OSS project. The study used learning opportunity episodes (LOE) as the embedded unit of analysis and developed and utilized three content analytic schemes to describe the characteristics of the learning process and the factors affecting this process.
},
	keywords = {apache, case study},
	doi = {http://dx.doi.org/10.1007/0-387-34226-5_8},
	attachments = {https://flosshub.org/sites/flosshub.org/files/From\%20Individual\%20Contribution\%20to\%20Group\%20Learning.pdf},
	author = {Hala Annabi and Kevin Crowston and Robert Heckman}
}
@article {flosswp113,
	title = {The Impact of Ideology on Effectiveness in Open Source Software Development Teams},
	journal = {MIS Quarterly},
	volume = {30},
	number = {2},
	year = {2006},
	note = {"...we collected data related to OSS projects hosted on Sourceforge (www.sourceforge.net)."
"Data was collected using two surveys and from the Sourceforge website."
},
	month = {2006},
	pages = {291-314},
	abstract = {The emerging work on understanding open source software has argued for the importance of understanding what leads to effectiveness in OSS development teams and has pointed to the importance of ideology. This paper develops a framework of the OSS ideology (including specific norms, beliefs, and values) and a theoretical model to show how adherence to components of the ideology impact effectiveness in OSS teams. The model is based on the idea that ideology provides clan control, which is important in OSS development settings because OSS teams generally lack formal behavioral and outcome controls. The paper hypothesizes both direct effects of ideology on OSS team effectiveness and indirect effects via influences on affective trust, cognitive trust, and communication quality. Hypotheses are tested using survey and objective data on OSS projects. Four effectiveness measures are used to capture unique aspects of effectiveness in OSS including both the extent to which a team attracts input from the community and the team{\textquoteright}s success in accomplishing project outcomes. Results support the main thesis that OSS team members{\textquoteright} adherence to the tenets of the OSS community ideology enhances OSS team effectiveness. The study uncovers several differences in the importance of OSS norms, beliefs, and values to different kinds of OSS team effectiveness and discusses implications for theory and practice.},
	keywords = {bug fixing, bug reports, bug tracking, communication, COMMUNITY, effectiveness, feature requests, ideology, metadata, sourceforge, Survey, team effort, team size, trust},
	attachments = {https://flosshub.org/sites/flosshub.org/files/stewartgosain2.pdf},
	author = {Stewart, K. and Gosain, S.}
}
@conference {Askari:2006:ITE:1137983.1138013,
	title = {Information theoretic evaluation of change prediction models for large-scale software},
	booktitle = {Proceedings of the 2006 international workshop on Mining software repositories},
	series = {MSR {\textquoteright}06},
	year = {2006},
	pages = {126{\textendash}132},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {In this paper, we analyze the data extracted from several open source software repositories. We observe that the change data follows a Zipf distribution. Based on the extracted data, we then develop three probabilistic models to predict which files will have changes or bugs. The first model is Maximum Likelihood Estimation (MLE), which simply counts the number of events, i.e., changes or bugs, that happen to each file and normalizes the counts to compute a probability distribution. The second model is Reflexive Exponential Decay (RED) in which we postulate that the predictive rate of modification in a file is incremented by any modification to that file and decays exponentially. The third model is called RED-Co-Change. With each modification to a given file, the RED-Co-Change model not only increments its predictive rate, but also increments the rate for other files that are related to the given file through previous co-changes. We then present an information-theoretic approach to evaluate the performance of different prediction models. In this approach, the closeness of model distribution to the actual unknown probability distribution of the system is measured using cross entropy. We evaluate our prediction models empirically using the proposed information-theoretic approach for six large open source systems. Based on this evaluation, we observe that of our three prediction models, the RED-Co-Change model predicts the distribution that is closest to the actual distribution for all the studied systems.},
	keywords = {bugs, change analysis, cvs, evaluation approach, file, freebsd, information theory, kde, koffice, log files, netbsd, openbsd, postgresql, prediction, prediction models, scm, source code},
	isbn = {1-59593-397-2},
	doi = {http://doi.acm.org/10.1145/1137983.1138013},
	url = {http://doi.acm.org/10.1145/1137983.1138013},
	attachments = {https://flosshub.org/sites/flosshub.org/files/126InformationTheoretic.pdf},
	author = {Askari, Mina and Holt, Ric}
}
@article {1232,
	title = {Integration of libre software applications to create a collaborative work platform for researchers at GET},
	journal = {International Journal of Information Technology and Web Engineering},
	volume = {1},
	number = {3},
	year = {2006},
	month = {07/2006},
	pages = {1-16},
	publisher = {IGI Global},
	abstract = {Libre software provides powerful applications ready to be integrated for the build-up of platforms for internal use in organizations. We describe the architecture of the collaborative work platform which we have integrated, designed for researchers at GET. We present the elements we have learned during this project in particular with respect to contribution to external libre projects, in order to better ensure the maintainability of the internal applications, and to phpGroupware as a framework for specific applications development.},
	keywords = {collaborative work environment, contribution, free software, groupware, in-house applications, libre software, open source software, OpenLDAP, phpGroupware, PicoLibre, ProGET, Sympa, TWiki, WebDAV, wiki},
	author = {Olivier Berger and Christian Bac and Benoit Hamet}
}
@conference {1094,
	title = {Knowledge Reuse in Open Source Software: An Exploratory Study of 15 Open Source Projects},
	booktitle = {Proceedings of the 38th Annual Hawaii International Conference on System Sciences},
	year = {2006},
	note = {"In a first step, we asked developers of different open source projects to respond to a very short web-based survey."...
"In a second step, we started with gathering data from 15 projects, including interviews. In parallel, the source code, CVS comments and to a certain extent email communication was analyzed to receive a dynamic, and within the limits of the method, complete picture of knowledge reuse practices."
"Projects included games (Adonthell, FlightGear, Xboard), text processing (Abiword), a GNU/Linux desktop (Xfce4), an instant messenger client (Miranda), fax software (HylaFAX), a content management system (Tiki/CMS Groupware), encryption software (OpenSSL), a collaborative music system (iRATE Radio), file sharing networks (GNUnet, Mnet, Freenet), a mailing list manager (Mailman), and an mp3 encoder (Lame)."
"Our data sources included interviews with key developers, source code, CVS comments, mailing lists and various Internet resources"},
	month = {2006},
	pages = {1-10},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Big Island, HI, USA},
	abstract = {To date, there is no investigation of knowledge reuse in open source software projects. This paper focuses on the forms of knowledge reuse and the factors impacting on them. It develops a theory drawn from data of 15 open source software projects and finds that the effort to search, integrate and maintain external knowledge influences the form of knowledge to be reused. Implications for firms and innovation research are discussed.},
	keywords = {cvs, email, knowledge reuse, lines of code, loc, source code, Survey},
	doi = {10.1109/HICSS.2005.378},
	url = {http://www.computer.org/csdl/proceedings/hicss/2005/2268/07/22680198b-abs.html},
	author = {von Krogh, G. and Spaeth, S. and Haefliger, S.}
}
@article {Yu:2006:MKO:1150566.1150571,
	title = {Maintainability of the kernels of open-source operating systems: A comparison of Linux with FreeBSD, NetBSD, and OpenBSD},
	journal = {J. Syst. Softw.},
	volume = {79},
	year = {2006},
	note = {"Data regarding the number and total number of lines of code of kernel and nonkernel modules in the four operating systems are provided in Table 1"
loc, kloc, number of kernel modules, number of nonkernel modules
size 
c files
.h files},
	month = {June},
	pages = {807{\textendash}815},
	publisher = {Elsevier Science Inc.},
	address = {New York, NY, USA},
	abstract = {We compared and contrasted the maintainability of four open-source operating systems: Linux, FreeBSD, NetBSD, and OpenBSD. We used our categorization of common coupling in kernel-based software to highlight future maintenance problems. An unsafe definition is a definition of a global variable that can affect a kernel module if that definition is changed. For each operating system we determined a number of measures, including the number of global variables, the number of instances of global variables in the kernel and overall, as well as the number of unsafe definitions in the kernel and overall. We also computed the value of each our measures per kernel KLOC and per KLOC overall. For every measure and every ratio, Linux compared unfavorably with FreeBSD, NetBSD, and OpenBSD. Accordingly, we are concerned about the future maintainability of Linux. },
	keywords = {abiword, Common coupling, coupling, Definition-use analysis, freebsd, kernel, lines of code, linux, linux kernel, loc, Maintainability, modules, netbsd, Open-source software, openbsd, source code},
	issn = {0164-1212},
	doi = {http://dx.doi.org/10.1016/j.jss.2005.08.014},
	url = {http://dx.doi.org/10.1016/j.jss.2005.08.014},
	attachments = {https://flosshub.org/sites/flosshub.org/files/YuSchachChen.pdf},
	author = {Yu, Liguo and Schach, Stephen R. and Chen, Kai and Heller, Gillian Z. and Offutt, Jeff}
}
@conference {Kim:2006:MPE:1137983.1137995,
	title = {Micro pattern evolution},
	booktitle = {Proceedings of the 2006 international workshop on Mining software repositories},
	series = {MSR {\textquoteright}06},
	year = {2006},
	pages = {40{\textendash}46},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {When analyzing the evolution history of a software project, we wish to develop results that generalize across projects. One approach is to analyze design patterns, permitting characteristics of the evolution to be associated with patterns, instead of source code. Traditional design patterns are generally not amenable to reliable automatic extraction from source code, yet automation is crucial for scalable evolution analysis. Instead, we analyze {\textquotedblleft}micro pattern{\textquotedblright} evolution; patterns whose abstraction level is closer to source code, and designed to be automatically extractable from Java source code or bytecode. We perform micro-pattern evolution analysis on three open source projects, ArgoUML, Columba, and jEdit to identify micro pattern frequencies, common kinds of pattern evolution, and bug-prone patterns. In all analyzed projects, we found that the micro patterns of Java classes do not change often. Common bug- prone pattern evolution kinds are {\textquoteleft}Pool {\textrightarrow} Pool{\textquoteright}, {\textquoteleft}Implementor {\textrightarrow} NONE{\textquoteright}, and {\textquoteleft}Sampler {\textrightarrow} Sampler{\textquoteright}. Among all pattern evolution	kinds,{\textquoteleft}Box{\textquoteright},{\textquoteleft}CompoundBox{\textquoteright},	{\textquoteleft}Pool{\textquoteright}, {\textquoteleft}CommonState{\textquoteright}, and {\textquoteleft}Outline{\textquoteright} micro patterns have high bug rates, but they have low frequencies and a small number of changes. The pattern evolution kinds that are bug-prone are somewhat similar across projects. The bug-prone pattern evolution kinds of two different periods of the same project are almost identical.},
	keywords = {argouml, bugs, columba, design patterns, evolution, extraction, java, jedit, source code},
	isbn = {1-59593-397-2},
	doi = {http://doi.acm.org/10.1145/1137983.1137995},
	url = {http://doi.acm.org/10.1145/1137983.1137995},
	attachments = {https://flosshub.org/sites/flosshub.org/files/40MicroPattern.pdf},
	author = {Kim, Sunghun and Pan, Kai and Whitehead,Jr., E. James}
}
@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 {Bird:2006:MES:1137983.1138016,
	title = {Mining email social networks},
	booktitle = {Proceedings of the 2006 international workshop on Mining software repositories},
	series = {MSR {\textquoteright}06},
	year = {2006},
	pages = {137{\textendash}143},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {Communication \& Co-ordination activities are central to large software projects, but are difficult to observe and study in traditional (closed-source, commercial) settings because of the prevalence of informal, direct communication modes. OSS projects, on the other hand, use the internet as the communication medium,and typically conduct discussions in an open, public manner. As a result, the email archives of OSS projects provide a useful trace of the communication and co-ordination activities of the participants. However, there are various challenges that must be addressed before this data can be effectively mined. Once this is done, we can construct social networks of email correspondents, and begin to address some interesting questions. These include questions relating to participation in the email; the social status of different types of OSS participants; the relationship of email activity and commit activity (in the CVS repositories) and the relationship of social status with commit activity. In this paper, we begin with a discussion of our infrastructure (including a novel use of Scientific Workflow software) and then discuss our approach to mining the email archives; and finally we present some preliminary results from our data analysis.},
	keywords = {communication, contributions, developers, email, email archives, mailing lists, open source, social networks},
	isbn = {1-59593-397-2},
	doi = {http://doi.acm.org/10.1145/1137983.1138016},
	url = {http://doi.acm.org/10.1145/1137983.1138016},
	attachments = {https://flosshub.org/sites/flosshub.org/files/137MiningEmail.pdf},
	author = {Christian Bird and Gourley, Alex and Devanbu, Prem and Gertz, Michael and Swaminathan, Anand}
}
@conference {WeiBgerber:2006:MRA:1137983.1138028,
	title = {Mining refactorings in ARGOUML},
	booktitle = {Proceedings of the 2006 international workshop on Mining software repositories},
	series = {MSR {\textquoteright}06},
	year = {2006},
	note = {"To see if refactorings in ARGOUML have an effect on the occurrence of new bugs and on communication between the developers, we relate the refactorings to bug reports in ISSUEZILLA respectively to mails on the developer mailing list. "},
	pages = {175{\textendash}176},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {In this paper we combine the results of our refactoring reconstruc- tion technique with bug, mail and release information to perform process and bug analyses of the ARGOUML CVS archive.},
	keywords = {argouml, bug tracking, bugs, cvs, email, evolution, mining challenge, msr challenge, re-engineering, refactoring, release history},
	isbn = {1-59593-397-2},
	doi = {http://doi.acm.org/10.1145/1137983.1138028},
	url = {http://doi.acm.org/10.1145/1137983.1138028},
	attachments = {https://flosshub.org/sites/flosshub.org/files/175MiningRefactorings.pdf},
	author = {Wei{\ss}gerber, Peter and Diehl, Stephan and G{\"o}rg, Carsten}
}
@conference {Kagdi:2006:MSC:1137983.1137996,
	title = {Mining sequences of changed-files from version histories},
	booktitle = {Proceedings of the 2006 international workshop on Mining software repositories},
	series = {MSR {\textquoteright}06},
	year = {2006},
	pages = {47{\textendash}53},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {Modern source-control systems, such as Subversion, preserve change-sets of files as atomic commits. However, the specific ordering information in which files were changed is typically not found in these source-code repositories. In this paper, a set of heuristics for grouping change-sets (i.e., log-entries) found in source-code repositories is presented. Given such groups of change-sets, sequences of files that frequently change together are uncovered. This approach not only gives the (unordered) sets of files but supplements them with (partial temporal) ordering information. The technique is demonstrated on a subset of KDE source-code repository. The results show that the approach is able to find sequences of changed-files.},
	keywords = {change, change history, change management, change sequences, heuristics, kde, mining software repositories, scm, sequences, source code},
	isbn = {1-59593-397-2},
	doi = {http://doi.acm.org/10.1145/1137983.1137996},
	url = {http://doi.acm.org/10.1145/1137983.1137996},
	attachments = {https://flosshub.org/sites/flosshub.org/files/47MiningSequences.pdf},
	author = {Kagdi, Huzefa and Yusuf, Shehnaaz and Maletic, Jonathan I.}
}
@conference {Voinea:2006:MSR:1137983.1138024,
	title = {Mining software repositories with CVSgrab},
	booktitle = {Proceedings of the 2006 international workshop on Mining software repositories},
	series = {MSR {\textquoteright}06},
	year = {2006},
	pages = {167{\textendash}168},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	keywords = {argouml, cvs, cvsgrab, evolution, mining challenge, msr challenge, postgresql, software visualization, source code, team, visualization},
	isbn = {1-59593-397-2},
	doi = {http://doi.acm.org/10.1145/1137983.1138024},
	url = {http://doi.acm.org/10.1145/1137983.1138024},
	attachments = {https://flosshub.org/sites/flosshub.org/files/167MiningSoftware.pdf},
	author = {Voinea, Lucian and Telea, Alexandru}
}
@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 {Voinea:2006:OFC:1137983.1137993,
	title = {An open framework for CVS repository querying, analysis and visualization},
	booktitle = {Proceedings of the 2006 international workshop on Mining software repositories},
	series = {MSR {\textquoteright}06},
	year = {2006},
	pages = {33{\textendash}39},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {We present an open framework for visual mining of CVS software repositories. We address three aspects: data extraction, analysis and visualization. We first discuss the challenges of CVS data extraction and storage, and propose a flexible way to deal with CVS implementation inconsistencies. We next present a new technique to enrich the raw data with information about artifacts showing similar evolution. Finally, we propose a visualization backend and show its applicability on industry-size repositories.},
	keywords = {argouml, cvs, cvsgrab, evolution visualization, postgresql, software visualization},
	isbn = {1-59593-397-2},
	doi = {http://doi.acm.org/10.1145/1137983.1137993},
	url = {http://doi.acm.org/10.1145/1137983.1137993},
	author = {Voinea, Lucian and Telea, Alexandru}
}
@article {2006,
	title = {Opportunities and Challenges Applying Functional Data Analysis to the Study of Open Source Software Evolution},
	journal = {Statistical Science},
	volume = {21},
	number = {2},
	year = {2006},
	note = {"As part of a larger project, data were collected on 105 OSS	projects hosted online at Sourceforge (sf.net)." "...we limited our data collection to projects that use only the Java programming language and were listed in the Internet and System Networking domains." "... only including these projects that use an OSI approved license..." "had to have posted at least one file on the Sourceforge site as of the time of our initial project selection Fall 2002" "Data were collected on the published release history of each project thatmet the screening criteria. Each release of each project was
analyzed to calculate CplXLCoh. The size of each release was measured using a calculation of the number of lines of code (LOC)"},
	pages = {167-178},
	publisher = {Institute of Mathematical Statistics},
	abstract = {This paper explores the application of functional data analysis (FDA) as a means to study the dynamics of software evolution in the open source context. Several challenges in analyzing the data from software projects are discussed, an approach to overcoming those challenges is described, and preliminary results from the analysis of a sample of open source software (OSS) projects are provided. The results demonstrate the utility of FDA for uncovering and categorizing multiple distinct patterns of evolution in the complexity of OSS projects. These results are promising in that they demonstrate some patterns in which the complexity of software decreased as the software grew in size, a particularly novel result. The paper reports preliminary explorations of factors that may be associated with decreasing complexity patterns in these projects. The paper concludes by describing several next steps for this research project as well as some questions for which more sophisticated analytical techniques may be needed.},
	keywords = {complexity, evolution, fda, java, lines of code, loc, release history, scm, size, sourceforge},
	issn = {08834237},
	url = {http://www.jstor.org/stable/27645747},
	author = {Stewart, Katherine J. and Darcy, David P. and Daniel, Sherae L.}
}
@conference {Knab:2006:PDD:1137983.1138012,
	title = {Predicting defect densities in source code files with decision tree learners},
	booktitle = {Proceedings of the 2006 international workshop on Mining software repositories},
	series = {MSR {\textquoteright}06},
	year = {2006},
	pages = {119{\textendash}125},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {With the advent of open source software repositories the data available for defect prediction in source files increased tremendously. Although traditional statistics turned out to derive reasonable results the sheer amount of data and the problem context of defect prediction demand sophisticated analysis such as provided by current data mining and machine learning techniques.In this work we focus on defect density prediction and present an approach that applies a decision tree learner on evolution data extracted from the Mozilla open source web browser project. The evolution data includes different source code, modification, and defect measures computed from seven recent Mozilla releases. Among the modification measures we also take into account the change coupling, a measure for the number of change-dependencies between source files. The main reason for choosing decision tree learners, instead of for example neural nets, was the goal of finding underlying rules which can be easily interpreted by humans. To find these rules, we set up a number of experiments to test common hypotheses regarding defects in software entities. Our experiments showed, that a simple tree learner can produce good results with various sets of input data.},
	keywords = {change analysis, data mining, decision tree learner, defect density, defect prediction, mozilla, prediction, release history, scm, source code, version control},
	isbn = {1-59593-397-2},
	doi = {http://doi.acm.org/10.1145/1137983.1138012},
	url = {http://doi.acm.org/10.1145/1137983.1138012},
	attachments = {https://flosshub.org/sites/flosshub.org/files/119Predicting.pdf},
	author = {Knab, Patrick and Pinzger, Martin and Bernstein, Abraham}
}
@conference {1229,
	title = {Regurgitate: Using GIT For F/LOSS Data Collection},
	booktitle = {1st Workshop on Public Data about Software Development (WoPDaSD 2006)},
	year = {2006},
	abstract = {We have created a new tool, regurgitate, for importing CVS repositories into the GIT source code management system. Important features of GIT include great expressiveness in capturing relationships between revisions and across files as well as extremely high-speed processing. These features make GIT an ideal platform for gathering detailed longitudinal metrics for open source projects. The availability of regurgitate facilitates using GIT as an analysis tool for that majority of open source projects that keep their repositories in CVS. In particular, GIT is fast enough that it is practical to replay the entire development history of a project commit-at-a-time, collecting metrics at each step. We demonstrate this process for a simple metric and a collection of benchmark F/LOSS repositories.},
	keywords = {cvs, cvsanaly, git, history, promise, regurgitate, scm},
	attachments = {https://flosshub.org/sites/flosshub.org/files/massey.pdf},
	author = {Bart Massey and Keith Packard}
}
@conference {708,
	title = {Social dynamics of free and open source team communications},
	booktitle = {OSS2006: Open Source Systems (IFIP 2.13)},
	series = {IFIP International Federation for Information Processing },
	volume = {203/2006},
	year = {2006},
	month = {06/2006},
	pages = {319 - 330},
	publisher = {Springer},
	organization = {Springer},
	abstract = {This paper furthers inquiry into the social structure of free and open source software (FLOSS) teams by undertaking social network analysis across time. Contrary to expectations, we confirmed earlier findings of a wide distribution of centralizations even when examining the networks over time. The paper also provides empirical evidence that while change at the center of FLOSS projects is relatively uncommon, participation across the project communities is highly skewed, with many participants appearing for only one period. Surprisingly, large project teams are not more likely to undergo change at their centers.
},
	keywords = {bug fixing, bug reports, bug tracker, bug tracking, bugs, communications, Dynamic social networks, FLOSS teams, Human Factors, social network analysis, software development, sourceforge},
	issn = {978-0-387-34225-2},
	doi = {http://dx.doi.org/10.1007/0-387-34226-5_32},
	attachments = {https://flosshub.org/sites/flosshub.org/files/Social\%20dynamics\%20of\%20free\%20and\%20open\%20source\%20team.pdf},
	author = {Howison, James and Inoue, Keisuke and Kevin Crowston}
}
@conference {German:2006:SCP:1137983.1138022,
	title = {A study of the contributors of PostgreSQL},
	booktitle = {Proceedings of the 2006 international workshop on Mining software repositories},
	series = {MSR {\textquoteright}06},
	year = {2006},
	pages = {163{\textendash}164},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {This report describes some characteristics of the development team of PostgreSQL that were uncovered by analyzing the history of its software artifacts as recorded by the project{\textquoteright}s CVS repository.},
	keywords = {contributions, contributors, cvs, developers, mining challenge, mining software repositories, msr challenge, patches, postgresql, revision history, roles, software evolution, source code, team},
	isbn = {1-59593-397-2},
	doi = {http://doi.acm.org/10.1145/1137983.1138022},
	url = {http://doi.acm.org/10.1145/1137983.1138022},
	attachments = {https://flosshub.org/sites/flosshub.org/files/163AStudyOf.pdf},
	author = {Daniel M. German}
}
@conference {1090,
	title = {A Topological Analysis of the Open Souce Software Development Community},
	booktitle = {Proceedings of the 38th Annual Hawaii International Conference on System Sciences},
	year = {2006},
	note = {"We extracted data from a 2003 data dump obtained from SourceForge. "
roles},
	pages = {1-10},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Big Island, HI, USA},
	abstract = {The fast growth of OSS has increased the interest in studying the composition of the OSS community and its collaboration mechanisms. Moreover, the success of a project may be related to the underlying social structure of the OSS development community. In this paper, we perform a quantitative analysis of Open Source Software developers by studying the entire development community at SourceForge [26]. Statistics and social network properties are explored to find collaborations and the effects of different members in the OSS development community. Small world phenomenon and scale free behaviors are found in the SourceForge development network. These topological properties may potentially explain the success and efficiency of OSS development practices. We also infer from our analysis that weakly associated but contributing co-developers and active users may be an important factor in OSS development.},
	keywords = {contributors, developers, roles, social network analysis, social networks, sourceforge, srda, users},
	doi = {10.1109/HICSS.2005.57},
	url = {http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.132.6830\&rep=rep1\&type=pdf},
	attachments = {https://flosshub.org/sites/flosshub.org/files/xuGao.pdf},
	author = {Jin Xu and Gao, Yongqin and Christley, S. and Madey, G.}
}
@article {1122,
	title = {Understanding the Motivations, Participation, and Performance of Open Source Software Developers: A Longitudinal Study of the Apache Projects},
	journal = {Management Science},
	volume = {52},
	year = {2006},
	note = {"analyzing archival data collected from OSS project records over a period of four years"
"Apart from the source and binary codes of the actual software programs, Apache products include developer websites, change logs, documentation, and developer communications in the form of e-mail archives. From these products, we extracted two types of information: each contributor{\textquoteright}s progression along the Apache career path, and each contributor{\textquoteright}s source code contributions to the project."},
	month = {07/2006},
	pages = {984 - 999},
	abstract = {Understanding what motivates participation is a central theme in the research on open source software (OSS) development. Our study contributes by revealing how the different motivations of OSS developers are interrelated, how these motivations influence participation leading to performance, and how past performance influences subsequent motivations. Drawing on theories of intrinsic and extrinsic motivation, we develop a theoretical model relating the motivations, participation, and performance of OSS developers. We evaluate our model using survey and archival data collected from a longitudinal field study of software developers in the Apache projects. Our results reveal several important findings. First, we find that developers{\textquoteright} motivations are not independent but rather are related in complex ways. Being paid to contribute to Apache projects is positively related to developers{\textquoteright} status motivations but negatively related to their use-value motivations. Perhaps surprisingly, we find no evidence of diminished intrinsic motivation in the presence of extrinsic motivations; rather, status motivations enhance intrinsic motivations. Second, we find that different motivations have an impact on participation in different ways. Developers{\textquoteright} paid participation and status motivations lead to above-average contribution levels, but use-value motivations lead to below-average contribution levels, and intrinsic motivations do not significantly impact average contribution levels. Third, we find that developers{\textquoteright} contribution levels positively impact their performance rankings. Finally, our results suggest that past-performance rankings enhance developers{\textquoteright} subsequent status motivations.},
	keywords = {apache, change logs, contributions, email, email archives, extrinsic motivation, intrinsic motivation, mailing lists, MOTIVATION, open source software, participation, software development performance, source code, status, Survey},
	issn = {1526-5501},
	doi = {10.1287/mnsc.1060.0554},
	author = {Roberts, Jeffrey A. and Il-Horn Hann and Slaughter, Sandra A.}
}
@conference {German:2006:UEA:1137983.1138020,
	title = {Using evolutionary annotations from change logs to enhance program comprehension},
	booktitle = {Proceedings of the 2006 international workshop on Mining software repositories},
	series = {MSR {\textquoteright}06},
	year = {2006},
	pages = {159{\textendash}162},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {Evolutionary annotations are descriptions of how source code evolves over time. Typical source comments, given their static nature, are usually inadequate for describing how a program has evolved over time; instead, source code comments are typically a description of what a program currently does. We propose the use of evolutionary annotations as a way of describing the rationale behind changes applied to a given program (for example "These lines were added to ..."). Evolutionary annotations can assist a software developer in the understanding of how a given portion of source code works by showing him how the source has evolved into its current form.In this paper we describe a method to automatically create evolutionary annotations from change logs, defect tracking systems and mailing lists. We describe the design of a prototype for Eclipse that can filter and present these annotations alongside their corresponding source code and in workbench views. We use Apache as a test case to demonstrate the feasibility of this approach.},
	keywords = {annotations, apache, bug tracking, change history, eclipse, evolutionary, log files, mailing lists, mining software repositories, software evolution, version control},
	isbn = {1-59593-397-2},
	doi = {http://doi.acm.org/10.1145/1137983.1138020},
	url = {http://doi.acm.org/10.1145/1137983.1138020},
	attachments = {https://flosshub.org/sites/flosshub.org/files/159UsingEvolutionary.pdf},
	author = {Daniel M. German and Peter C. Rigby and Storey, Margaret-Anne}
}
@conference {Kakimoto:2006:USB:1137983.1138026,
	title = {Using software birthmarks to identify similar classes and major functionalities},
	booktitle = {Proceedings of the 2006 international workshop on Mining software repositories},
	series = {MSR {\textquoteright}06},
	year = {2006},
	pages = {171{\textendash}172},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	keywords = {argouml, class, file, mining challenge, msr challenge, multi-dimensional scaling, similarity, software birthmark, source code},
	isbn = {1-59593-397-2},
	doi = {http://doi.acm.org/10.1145/1137983.1138026},
	url = {http://doi.acm.org/10.1145/1137983.1138026},
	attachments = {https://flosshub.org/sites/flosshub.org/files/171UsingSoftware.pdf},
	author = {Kakimoto, Takeshi and Monden, Akito and Kamei, Yasutaka and Tamada, Haruaki and Tsunoda, Masateru and Matsumoto, Ken-ichi}
}
@conference {699,
	title = {On the Weickian Model in the Context of Open Source Software Development: Some Preliminary Insights},
	booktitle = {OSS2006: Open Source Systems (IFIP 2.13)},
	series = {IFIP International Federation for Information Processing},
	year = {2006},
	pages = {3 - 8},
	publisher = {Springer},
	organization = {Springer},
	abstract = {Despite being regarded as a path-breaking model of organising, Weick{\textquoteright}s Enactment-Selection-Retention (ESR) model has been labelled too abstract a model find any practical applications. This paper attempts to show that exploration-oriented open source projects represent valuable case studies where Weick{\textquoteright}s ESR model can be applied. By taking the Linux case study as a case in point, it is argued that a qualitative analysis of micro interactions (i.e. double interacts) might reveal broad organising patterns. Preliminary implications in terms of coordination and knowledge making processes are discussed in the final section.
},
	keywords = {case study, linux},
	doi = {http://dx.doi.org/10.1007/0-387-34226-5_1},
	attachments = {https://flosshub.org/sites/flosshub.org/files/On\%20the\%20Weickian\%20Model\%20in\%20the\%20Context.pdf},
	author = {Iannacci, Federico}
}
@conference {Canfora:2006:BRK:1137983.1138032,
	title = {Where is bug resolution knowledge stored?},
	booktitle = {Proceedings of the 2006 international workshop on Mining software repositories},
	series = {MSR {\textquoteright}06},
	year = {2006},
	pages = {183{\textendash}184},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {ArgoUML uses both CVS and Bugzilla to keep track of bug-fixing activities since 1998. A common practice is to reference source code changes resolving a bug stored in Bugzilla by inserting the id number of the bug in the CVS commit notes. This relationship reveals useful to predict code entities impacted by a new bug report.In this paper we analyze ArgoUML software repositories with a tool, we have implemented, showing what are Bugzilla fields that better predict such impact relationship, that is where knowledge about bug resolution is stored.},
	keywords = {argouml, bugs, bugzilla, cvs, impact analysis, mining challenge, mining software repositories, msr challenge, source code},
	isbn = {1-59593-397-2},
	doi = {http://doi.acm.org/10.1145/1137983.1138032},
	url = {http://doi.acm.org/10.1145/1137983.1138032},
	attachments = {https://flosshub.org/sites/flosshub.org/files/183WhereIsBug.pdf},
	author = {Canfora, Gerardo and Cerulo, Luigi}
}
@conference {Ohira:2005:ACK:1083142.1083163,
	title = {Accelerating cross-project knowledge collaboration using collaborative filtering and social networks},
	booktitle = {Proceedings of the 2005 international workshop on Mining software repositories},
	series = {MSR {\textquoteright}05},
	year = {2005},
	pages = {111-115},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {Vast numbers of free/open source software (F/OSS) development projects use hosting sites such as Java.net and SourceForge.net. These sites provide each project with a variety of software repositories (e.g. repositories for source code sharing, bug tracking, discussions, etc.) as a media for communication and collaboration. They tend to focus on supporting rich collaboration among members in each project. However, a majority of hosted projects are relatively small projects consisting of few developers and often need more resources for solving problems. In order to support cross-project knowledge collaboration in F/OSS development, we have been developing tools to collect data of projects and developers at SourceForge, and to visualize the relationship among them using the techniques of collaborative filtering and social networks. The tools help a developer identify {\textquotedblleft}who should I ask?{\textquotedblright} and {\textquotedblleft}what can I ask?{\textquotedblright} and so on. In this paper, we report a case study of applying the tools to F/OSS projects data collected from SourceForge and how effective the tools can be used for helping cross-project knowledge collaboration.},
	keywords = {collaborative filtering, developers, knowledge collaboration, projects, social networks, sourceforge, visualization tool},
	isbn = {1-59593-123-6},
	doi = {http://doi.acm.org/10.1145/1082983.1083163},
	url = {http://doi.acm.org/10.1145/1082983.1083163},
	attachments = {https://flosshub.org/sites/flosshub.org/files/111Accelerating.pdf},
	author = {Ohira, Masao and Ohsugi, Naoki and Ohoka, Tetsuya and Matsumoto, Ken-ichi}
}
@article {1079,
	title = {Are All Open Source Projects Created Equal? Understanding the Sustainability of Open Source Software Development Model},
	journal = {AMCIS 2005 Proceedings},
	number = {435},
	year = {2005},
	note = {uses first 300 most active projects on Sourceforge: {\textquoteright}Our data sample consists of 300 open source software development projects hosted in the Sourceforge.Net. They are the first 300 active projects ranked by Sourceforge.Net....Our dependent variable in the model to measure the success of the projects is the number of downloads. It is an essential variable to show how successful the project is. Generally, more number of downloads means a more successful project. Independent variables include: development status, project lifespan, number of developers, number of messages in the forums, number of mailing list, number of bug report, number of patch report, number of CVS report, number of file releases and also number of news release."},
	abstract = {A very intriguing question in Open Source software (OSS) development is: why there are only a few open source projects succeed, while the majority of projects never do. In this research, we examine the factors that may influence the performance of OSS projects. We particularly focus on the OSS{\textquoteright}s core developers{\textquoteright} role in the project{\textquoteright}s success. Extant research has yet to distinguish core developers and non-core developers from the community at large. The different roles of the core developers and non-core developers in OSS projects{\textquoteright} success still remain unclear. Our research contributes to the literature by separating the core developers from the development forces in general and empirically examining the core developers{\textquoteright} importance. Drawing the evidences from our extensive dataset of 300 open source projects, we demonstrated that core developers{\textquoteright} leadership and project advocation are crucial in determining the fate of the OSS projects. Our research could provide better understanding of OSS sustainability. It could also give practical advice to the OSS community on how to make the project successful.},
	keywords = {contributors, core, developers, downloads, metadata, project success, sourceforge},
	attachments = {https://flosshub.org/sites/flosshub.org/files/LongYuan.pdf},
	author = {Long, J. and Yuan, M.J.}
}
@conference {779,
	title = {Carrot2 Clustering Framework},
	booktitle = {OSS2005: Open Source Systems },
	year = {2005},
	pages = {298-299},
	abstract = {Carrot2 is an Open Source framework for research experiments with querying various textual data sources, processing and presentation of the results. Its main goal is to promote component reuse in order to reduce the effort involved in the development of Information Retrieval software. So far, the most successful and popular application of Carrot2 has been organizing results of Internet searches into easy to browse thematic groups called clusters. In this area, the project successfully competes with commercial counterparts like Vivisimo or iBoogie.},
	keywords = {BSD license, cluster, clustering framework, open source, research, result},
	url = {http://pascal.case.unibz.it/handle/2038/788},
	author = {Weiss, Dawid and Osi{\textasciiacute}nski, Stanis{\l}aw}
}
@conference {795,
	title = {The challenges of creating open source education software: the Gild experience},
	booktitle = {OSS2005: Open Source Systems },
	year = {2005},
	pages = {338-340},
	keywords = {COMMUNITY, eclipse, learning environment, novice programmers, open source, programming environment},
	url = {http://pascal.case.unibz.it/handle/2038/1539},
	author = {Daniel M. German and Rigby, Peter and Cubranic, Davor and Storey, Margaret-Anne and Thomson, Suzanne}
}
@proceedings {89,
	title = {Coordination of Free/Libre Open Source Software development},
	year = {2005},
	note = {"The data used for the study were interactions on the main developer communication venue, either a developer mailing list or online forum"
sourceforge
},
	address = {Las Vegas, NV, USA},
	abstract = {The apparent success of free/libre open source software (FLOSS) development projects such as Linux, Apache, and many others has raised the question, what lessons from FLOSS development can be transferred to mainstream software development? In this paper, we use coordination theory to analyze coordination mechanisms in FLOSS development and compare our analysis with existing literature on coordination in proprietary software development. We examined developer interaction data from three active and successful FLOSS projects and used content analysis to identify the coordination mechanisms used by the participants. We found that there were similarities between the FLOSS groups and the reported practices of the proprietary project in the coordination mechanisms used to manage task-task dependencies. However, we found clear differences in the coordination mechanisms used to manage task-actor dependencies. While published descriptions of proprietary software development involved an elaborate system to locate the developer who owned the relevant piece of code, we found that {\textquotedblleft}self-assignment{\textquotedblright} was the most common mechanism across three FLOSS projects. This coordination mechanism is consistent with expectations for distributed and largely volunteer teams. We conclude by discussing whether these emergent practices can be usefully transferred to mainstream practice and indicating directions for future research.},
	keywords = {case study, compiere, coordination, egroupware, email, email archives, FLOSS, gaim, mailing list},
	attachments = {https://flosshub.org/sites/flosshub.org/files/CrowstonWeiLiEseryelHowison.pdf},
	author = {Kevin Crowston and Kangning Wei and Li, Qing and Eseryel, U. Yeliz and Howison, James}
}
@proceedings {citeulike:3052508,
	title = {Development Success in Open Source Software Projects: Exploring the Impact of Copylefted Licenses},
	year = {2005},
	abstract = {Copyleft prevents the source code of open source software (OSS) from being privately appropriated. The ethos of the OSS movement suggests that volunteer developers may particularly value and contribute to copylefted projects. Based on social movement theory, we hypothesized that copylefted OSS projects are more likely than non-copylefted OSS projects to succeed in the development process, in terms of two key indicators: developer membership and developer productivity. We performed an exploratory study using data from 62 relevant OSS projects spanning an average of three years of development time. We found that copylefted projects were associated with higher developer membership and productivity. This is the first study to empirically test the relationship between copylefted licenses and OSS project success. Implications for OSS project initiators as well as future research directions are discussed.},
	keywords = {contributions, copyleft, developer, developers, membership, productivity, project success, success},
	url = {http://aisel.isworld.org/password.asp?Vpath=AMCIS/2005\&\#38;PDFpath=OSSDAU01-1167.pdf},
	author = {Colazo, Jorge A. and Fang, Yulin and Neufeld, Derrick J.}
}
@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 {102,
	title = {Empirical validation of object-oriented metrics on open source software for fault prediction},
	journal = {IEEE Transactions on Software Engineering},
	volume = {31},
	number = {10},
	year = {2005},
	note = {"This paper describes how we calculated the object-oriented metrics given by Chidamber and Kemerer to illustrate how fault-proneness detection of the source code of the open source Web and e-mail suite called Mozilla can be carried out. We checked the values obtained against the number of bugs found in its bug database - called Bugzilla - using regression and machine learning methods to validate the usefulness of these metrics for fault-proneness prediction. We also compared the metrics of several versions of Mozilla to see how the predicted fault-proneness of the software system changed during its development cycle."
metrics, 
wmc weighted methods per class, 
dit depth of inheritance, 
rfc response for a class,
noc number of children,
cbo coupling between object classes,
cohesion,
lines of code, loc, sloc
chidamber and kemerer metrics},
	pages = {897-910},
	abstract = {Open source software systems are becoming increasingly important these days. Many companies are investing in open source projects and lots of them are also using such software in their own work. But, because open source software is often developed with a different management style than the industrial ones, the quality and reliability of the code needs to be studied. Hence, the characteristics of the source code of these projects need to be measured to obtain more information about it. This paper describes how we calculated the object-oriented metrics given by Chidamber and Kemerer to illustrate how fault-proneness detection of the source code of the open source Web and e-mail suite called Mozilla can be carried out. We checked the values obtained against the number of bugs found in its bug database - called Bugzilla - using regression and machine learning methods to validate the usefulness of these metrics for fault-proneness prediction. We also compared the metrics of several versions of Mozilla to see how the predicted fault-proneness of the software system changed during its development cycle.},
	keywords = {bugs, bugzilla, cbo, defects, dit, fault-prone modules, faults, lcom, lcomn, loc, metrics, mozilla, noc, object-oriented, rfc, source code, wmc},
	url = {http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.115.8372\&rep=rep1\&type=pdf},
	attachments = {https://flosshub.org/sites/flosshub.org/files/Gyimothy.pdf},
	author = {Gyimothy, T. and Ferenc, R. and Siket, I.}
}
@conference {Gorg:2005:EDR:1083142.1083148,
	title = {Error detection by refactoring reconstruction},
	booktitle = {Proceedings of the 2005 international workshop on Mining software repositories},
	series = {MSR {\textquoteright}05},
	year = {2005},
	pages = {29-33},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {In many cases it is not sufficient to perform a refactoring only at one location of a software project. For example, refactorings may have to be performed consistently to several classes in the inheritance hierarchy, e.g. subclasses or implementing classes, to preserve equal behavior.In this paper we show how to detect incomplete refactorings - which can cause long standing bugs because some of them do not cause compiler errors - by analyzing software archives. To this end we reconstruct the class inheritance hierarchies, as well as refactorings on the level of methods. Then, we relate these refactorings to the corresponding hierarchy in order to find missing refactorings and thus, errors and inconsistencies that have been introduced in a software project at some point of the history.Finally. we demonstrate our approach by case studies on two open source projects.},
	keywords = {bugs, class, inheritance, jedit, refactoring, tomcat},
	isbn = {1-59593-123-6},
	doi = {http://doi.acm.org/10.1145/1082983.1083148},
	url = {http://doi.acm.org/10.1145/1082983.1083148},
	attachments = {https://flosshub.org/sites/flosshub.org/files/29ErrorDetection.pdf},
	author = {G{\"o}rg, Carsten and Wei{\ss}gerber, Peter}
}
@conference {731,
	title = {Evolution of Volunteer Participation in Libre Software Projects: Evidence from Debian},
	booktitle = {OSS2005: Open Source Systems },
	year = {2005},
	note = {"For each release we have retrieved the corresponding sources.gz file (see below) from the Debian archive. From it we have extracted information about the packages and their maintainers...."
},
	pages = {100-107},
	abstract = {Most libre software projects rely on the work of volunteers. Therefore, attracting people who contribute their time and technical skills is of paramount importance, both in technical and economic terms. This reliance on volunteers leads to some fundamental management challenges: volunteer contributions are inherently difficult to predict, plan and manage, especially in the case of large projects. In this paper we analyze the evolution in time of the human resources of one of the largest and most complex libre software projects composed primarily of volunteers, the Debian project. Debian currently has around 1300 volunteers working on several tasks: much activity is focused on packaging software applications and libraries, but there is also major work related to the maintenance of the infrastructure needed to sustain the development. We have performed a quantitative investigation of data from almost seven years, studying how volunteer involvement has affected the software...},
	keywords = {contributors, debian, maintainers, PopCon, popularity, Volunteers},
	url = {http://pascal.case.unibz.it/handle/2038/857},
	attachments = {https://flosshub.org/sites/flosshub.org/files/robles_barahona_michlmayr-evolution_participation.pdf},
	author = {Gregorio Robles and Jesus M. Gonzalez-Barahona and Martin Michlmayr}
}
@conference {792,
	title = {Experiences teaching a graduate course in Open Source Software Engineering},
	booktitle = {OSS2005: Open Source Systems },
	year = {2005},
	pages = {326-328},
	abstract = {This paper describes the early experiences of a graduate course in open source software engineering at the Department of Computer Science at the University Victoria. It includes a description of the motivation for the course, its structure and evaluation methods. It concludes with a discussion of the lessons learned and its future.},
	keywords = {course, FOSS, MOTIVATION, open source, open source software engineering},
	url = {http://pascal.case.unibz.it/handle/2038/971},
	author = {Daniel M. German}
}
@article {flosswp184,
	title = {Exploring the Structure of Complex Software Designs: An Empirical Study of Open Source and Proprietary Code (updated)},
	year = {2005},
	note = {"For each design, we report data on the number of source files, the number of dependencies, the density of the DSM (i.e., the number of dependencies per source file pair) the propagation cost and the clustered cost. We also provide data on the average complexity of source files, in terms of the number of functions and lines of code."},
	month = {June},
	abstract = {This paper reports data from a study that seeks to characterize the differences in design structure between complex software products. In particular, we use Design Structure Matrices (DSMs) to map the dependencies between the elements of a design and define metrics that allow us to compare the structures of different designs. We first use these metrics to compare the architectures of two software products - the Linux operating system and the Mozilla web browser - that were developed via contrasting modes of organization: specifically, open source versus proprietary development. We then track the evolution of Mozilla, paying particular attention to a purposeful "re-design" effort that was undertaken with the intention of making the product more "modular." We find significant differences in structure between Linux and the first version of Mozilla, suggesting that Linux had a more modular architecture. We also find that the redesign of Mozilla resulted in an architecture that was significantly more modular than that of its predecessor, and indeed, than that of Linux. Our results, while exploratory, are consistent with a view that different modes of organization are associated with designs that possess different structures. However, we also illustrate that purposeful managerial actions can have a large impact on structure. This latter result is important given recent moves to release proprietary software into the public domain. These moves are likely to fail unless the product possesses an architecture that facilitates participation. Our paper provides evidence that a tightly-coupled design can be adapted to meet this objective.},
	keywords = {complexity, cost, dependencies, functions, lines of code, linux, loc, mozilla, source code},
	attachments = {https://flosshub.org/sites/flosshub.org/files/maccormackrusnakbaldwin2.pdf},
	author = {Alan MacCormack and John Rusnak and Carliss Baldwin}
}
@article {DBLP:journals/tse/Dinh-TrongB05,
	title = {The FreeBSD Project: A Replication Case Study of Open Source Development},
	journal = {IEEE Trans. Software Eng.},
	volume = {31},
	number = {6},
	year = {2005},
	note = {" we obtained the necessary data from the [FreeBsd] CVS repository, the bug report database, and the e-mail archive. The CVS repository contains all of the code and related documentation that is committed to the project from 1993 until the present. The bug report database contains information describing all reported problems, as well as the status (such as fixed, under test, or open) of each problem. Each bug report is called a PR and assigned a reference number. The e-mail archive contains every e-mail message exchanged between the developers since 1994."

d/l: research.cs.queensu.ca/~ahmed/home/teaching/.../F06/.../free-bsd.pdf},
	pages = {481-494},
	abstract = {Case studies can help to validate claims that open source software development produces higher quality software at lower cost than traditional commercial development. One problem inherent in case studies is external validity{\textemdash}we do not know whether or not results from one case study apply to another development project. We gain or lose confidence in case study results when similar case studies are conducted on other projects. This case study of the FreeBSD project, a long-lived open source project, provides further understanding of open source development. The paper details a method for mining repositories and querying project participants to retrieve key process information. The FreeBSD development process is fairly well-defined with proscribed methods for determining developer responsibilities, dealing with enhancements and defects, and managing releases. Compared to the Apache project, FreeBSD uses 1) a smaller set of core developers{\textemdash}developers who control the code base{\textemdash}that implement a smaller percentage of the system, 2) a larger set of top developers to implement 80 percent of the system, and 3) a more well-defined testing process. FreeBSD and Apache have a similar ratio of core developers to people involved in adapting and debugging the system and people who report problems. Both systems have similar defect densities and the developers are also users in both systems.},
	keywords = {apache, bug reports, contributors, core, cvs, defect density, developers, email, email archive, freebsd, mailing list, scm, source code, users},
	doi = {10.1109/TSE.2005.73},
	attachments = {https://flosshub.org/sites/flosshub.org/files/DinhTrungBieman.pdf},
	author = {Trung T. Dinh-Trong and James M. Bieman}
}
@article {vanWendeldeJoode2005109,
	title = {Handling variety: the tension between adaptability and interoperability of open source software},
	journal = {Computer Standards \& Interfaces},
	volume = {28},
	number = {1},
	year = {2005},
	note = {unable to find concise description of the data used [ms]},
	pages = {109 - 121},
	abstract = {Open source software (OSS) offers unprecedented opportunities to create variety. This could lead to incompatibility and fragmentation. To prevent this some form of coordination is needed. This paper explores which mechanisms of coordination are responsible for limiting divergence in OSS. Two cases are examined: Java and Linux. A systematic difference seems to exist between the mechanisms identified in the two communities. With respect to Java, divergence is where possible avoided ex ante, whereas for Linux divergence is foremost reduced ex post. The conclusion discusses this difference and the implications of both types of coordination in respect to interoperability.},
	keywords = {coordination, divergence, java, linux},
	issn = {0920-5489},
	doi = {DOI: 10.1016/j.csi.2004.12.004},
	url = {http://www.sciencedirect.com/science/article/B6TYV-4F6K72H-1/2/c74c64ce51e6f46abf9f39ae945c9e15},
	author = {Ruben van Wendel de Joode and Tineke M. Egyedi}
}
@conference {787,
	title = {Knowledge, Communication and Innovation: the case of Open Source Software as Open Media},
	booktitle = {OSS2005: Open Source Systems },
	year = {2005},
	pages = {314-316},
	abstract = {The understanding of the major characteristics of Linux Operative System and, more in general, the analysis of the so-called Open Source Phenomenon, is nowadays a central issue in order to appreciate the ongoing evolution of software industry. Free/Open Source Software model may appears a {\textquotedblleft}revolution{\textquotedblright} in the way of thinking about software development, distribution and use. But, at a closer glance, it reveals itself more as an {\textquotedblleft}evolution{\textquotedblright} along the path of {\textquotedblleft}tinkering with software{\textquotedblright} typical of the Hacker Tech-Culture since the beginning of sixties. In fact the {\textquotedblleft}open source way{\textquotedblright} of developing software results from the hackers habit of sharing technological knowledge and it represents a perfection of this, due to the availably of new communication technologies. The aim of this research is to explain this evolution, to point out its historical, economics and technological determinants and to link it with the evolution of the {\textquotedblleft}communicational medium{\textquotedblright} used by the open source ...},
	keywords = {attributive, Creative Commons, non-commercial},
	url = {http://pascal.case.unibz.it/handle/2038/972},
	author = {Lorenzo Benussi}
}
@conference {789,
	title = {Legal issues of Open Source Software},
	booktitle = {OSS2005: Open Source Systems },
	year = {2005},
	pages = {320-321},
	abstract = {From the legal standpoint, Open Source amounts to distributing rights and obligations in software license agreements in such a way, that they would (1) both grant users control over the program and (2) facilitate the sharing of improvements. The Open Source idea aims at reversing the process usually referred to as proprietary licensing and equaling the rights of the users with these of the authors. To some extent, it attempts to destroy monopolies created by copyright laws and to prevent them to arise again. There is much in the discussion on the legal issues of Open Source. The first voices came from the programmers who started the movement.},
	keywords = {cooperation, copyright law, freedom, intellectual property, legal issue, license, open source software},
	url = {http://pascal.case.unibz.it/handle/2038/974},
	author = {Siewicz, Krzysztof}
}
@conference {Antoniol:2005:LPC:1083142.1083156,
	title = {Linear predictive coding and cepstrum coefficients for mining time variant information from software repositories},
	booktitle = {Proceedings of the 2005 international workshop on Mining software repositories},
	series = {MSR {\textquoteright}05},
	year = {2005},
	pages = {74-78},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {This paper presents an approach to recover time variant information from software repositories. It is widely accepted that software evolves due to factors such as defect removal, market opportunity or adding new features. Software evolution details are stored in software repositories which often contain the changes history. On the other hand there is a lack of approaches, technologies and methods to efficiently extract and represent time dependent information. Disciplines such as signal and image processing or speech recognition adopt frequency domain representations to mitigate differences of signals evolving in time. Inspired by time-frequency duality, this paper proposes the use of Linear Predictive Coding (LPC) and Cepstrum coefficients to model time varying software artifact histories. LPC or Cepstrum allow obtaining very compact representations with linear complexity. These representations can be used to highlight components and artifacts evolved in the same way or with very similar evolution patterns. To assess the proposed approach we applied LPC and Cepstral analysis to 211 Linux kernel releases (i.e., from 1.0 to 1.3.100), to identify files with very similar size histories. The approach, the preliminary results and the lesson learned are presented in this paper.},
	keywords = {change history, data mining, evolution, files, kernel, linear predictive coding, linux, lpc, size, software evolution, source code},
	isbn = {1-59593-123-6},
	doi = {http://doi.acm.org/10.1145/1082983.1083156},
	url = {http://doi.acm.org/10.1145/1082983.1083156},
	attachments = {https://flosshub.org/sites/flosshub.org/files/74LinearPredictive.pdf},
	author = {Antoniol, Giuliano and Rollo, Vincenzo Fabio and Venturi, Gabriele}
}
@conference {791,
	title = {Looking at Free and Open Source Software: A Study about F/OSS Developers{\textquoteright} Culture},
	booktitle = {OSS2005: Open Source Systems },
	year = {2005},
	pages = {324-325},
	abstract = {My work will be a cultural study of a F/OSS development project, mixing a symmetric approach with the interaction analysis by Erving Goffman. Methodologically I will approach cyber {\textendash} ethnography.},
	keywords = {cultural analysis, cultural study, cyber, F/OSS developers, open source, software development},
	url = {http://pascal.case.unibz.it/handle/2038/968},
	author = {Teli, Maurizio}
}
@conference {Fischer:2005:MED:1083142.1083145,
	title = {Mining evolution data of a product family},
	booktitle = {Proceedings of the 2005 international workshop on Mining software repositories},
	series = {MSR {\textquoteright}05},
	year = {2005},
	pages = {12-16},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {Diversification of software assets through changing requirements impose a constant challenge on the developers and maintainers of large software systems. Recent research has addressed the mining for data in software repositories of single products ranging from fine- to coarse grained analyses. But so far, little attention has been payed to mining data about the evolution of product families. In this work, we study the evolution and commonalities of three variants of the BSD (Berkeley Software Distribution), a large open source operating system. The research questions we tackle are concerned with how to generate high level views of the system discovering and indicating evolutionary highlights. To process the large amount of data, we extended our previously developed approach for storing release history information to support the analysis of product families. In a case study we apply our approach on data from three different code repositories representing about 8.5GB of data and 10 years of active development.},
	keywords = {bsd, change analysis, change history, cvs, evolution, freebsd, netbsd, openbsd, release history, source code, text mining},
	isbn = {1-59593-123-6},
	doi = {http://doi.acm.org/10.1145/1082983.1083145},
	url = {http://doi.acm.org/10.1145/1082983.1083145},
	attachments = {https://flosshub.org/sites/flosshub.org/files/12MiningEvolution.pdf},
	author = {Fischer, Michael and Oberleitner, Johann and Ratzinger, Jacek and Gall, Harald}
}
@conference {Huang:2005:MVH:1083142.1083158,
	title = {Mining version histories to verify the learning process of Legitimate Peripheral Participants},
	booktitle = {Proceedings of the 2005 international workshop on Mining software repositories},
	series = {MSR {\textquoteright}05},
	year = {2005},
	pages = {84-88},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {Since code revisions reflect the extent of human involvement in the software development process, revision histories reveal the interactions and interfaces between developers and modules.We therefore divide developers and modules into groups according to the revision histories of the open source software repository, for example, sourceforge.net. To describe the interactions in the open source development process, we use a representative model, Legitimate Peripheral Participation (LPP) [6], to divide developers into groups such as core and peripheral teams, based on the evolutionary process of learning behavior.With the conventional module relationship, we divide modules into kernel and non-kernel types (such as UI). In the past, groups of developers and modules have been partitioned naturally with informal criteria. In this work, however, we propose a developer-module relationship model to analyze the grouping structures between developers and modules. Our results show some process cases of relative importance on the constructed graph of project development. The graph reveals certain subtle relationships in the interactions between core and non-core team developers, and the interfaces between kernel and non-kernel modules.},
	keywords = {awstats, bzflag, cvs, filezilla, gallery, Legitimate Peripheral Participants (LPP), moodle, open boundary, open source software development process, phpmyadmin, social networks, sourceforge},
	isbn = {1-59593-123-6},
	doi = {http://doi.acm.org/10.1145/1082983.1083158},
	url = {http://doi.acm.org/10.1145/1082983.1083158},
	attachments = {https://flosshub.org/sites/flosshub.org/files/84MiningVersion.pdf},
	author = {Huang, Shih-Kun and Liu, Kang-min}
}
@conference {803,
	title = {Open Source firms: from community to business},
	booktitle = {OSS2005: Open Source Systems },
	year = {2005},
	pages = {362-363},
	abstract = {A large body of literature is now addressing the Open Source (OS) phenomenon. Economic scholars have deeply investigated the incentives of people working within OS community projects; the software production models in absence of explicit hierarchical structures; the successful dissemination of OS programs in environments dominated by proprietary standards; the peculiarities in the management of intellectual property within the OS framework. Theoretical contributions have coupled with the collection of extensive empirical evidence mainly through surveys taken on individual developers. Nowadays a new trend is shaping the OS movement: more and more firms are entering the market by offering software solutions based on the new paradigm (Open Source firms).},
	keywords = {business, COMMUNITY, firms, Open Source firms},
	url = {http://pascal.case.unibz.it/handle/2038/1265},
	author = {Andrea Bonaccorsi and Cristina Rossi}
}
@conference {Phadke:2005:PRM:1145319.1145337,
	title = {Predicting risky modules in open-source software for high-performance computing},
	booktitle = {Proceedings of the second international workshop on Software engineering for high performance computing system applications},
	series = {SE-HPCS {\textquoteright}05},
	year = {2005},
	pages = {60{\textendash}64},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {This paper presents the position that software-quality modeling of open-source software for high-performance computing can identify modules that have a high risk of bugs.Given the source code for a recent release, a model can predict which modules are likely to have bugs, based on data from past releases. If a user knows which software modules correspond to functionality of interest, then risks to operations become apparent. If the risks are too great, the user may prefer not to upgrade to the most recent release.Of course, such predictions are never perfect. After release, bugs are discovered. Some bugs are missed by the model, and some predicted errors do not occur. A successful model will be accurate enough for informed management action at the time of the predictions.As evidence for this position, this paper summarizes a case study of the Portable Extensible Toolkit for Scientific Computation (PETSC), which is a mathematical library for high-performance computing. Data was drawn from source-code and configuration management logs. The accuracy of logistic-regression and decision-tree models indicated that the methodology is promising. The case study also illustrated several modeling issues.},
	keywords = {C4.5, decision trees, empirical case study, high performance computing, logistic regression, Open-source software, PETSc, software metrics, software quality model, software reliability},
	isbn = {1-59593-117-1},
	doi = {10.1145/1145319.1145337},
	url = {http://doi.acm.org/10.1145/1145319.1145337},
	author = {Phadke, Amit A. and Allen, Edward B.}
}
@conference {Stewart:2005:PAI:1042438.1043100,
	title = {A Preliminary Analysis of the Influences of Licensing and Organizational Sponsorship on Success in Open Source Projects},
	booktitle = {Proceedings of the Proceedings of the 38th Annual Hawaii International Conference on System Sciences - Volume 07},
	series = {HICSS {\textquoteright}05},
	year = {2005},
	note = {"Publicly available data on open source projects registered on the Freshmeat website (www.freshmeat.net) was used to test the hypotheses. Data was collected from each project{\textquoteright}s Freshmeat website at the start and end of an eight month period (March - December 2002)."
"We first selected three project categories from which to draw our sample. These were utilities, software development, and games."
"Within these categories we further differentiated between new projects, which had been registered on the site within the two weeks prior to our first data collection point and older projects that had been registered more than two weeks prior to our initial data collection."
},
	month = {2005},
	pages = {1-10},
	publisher = {IEEE Computer Society},
	organization = {IEEE Computer Society},
	address = {Washington, DC, USA},
	abstract = {This paper develops and tests a model of the impact of	licensing restrictiveness	and	organizational sponsorship on the popularity and vitality of open source software (OSS) development projects. Using data gathered from Freshmeat.net and OSS project home pages the main conclusions derived from the analysis are that organizational sponsorship has a positive effect on project popularity by easing user concerns about cost and quality and that license restrictiveness may have a negative effect on popularity by reducing the perceived utility of open source software. Theoretical and practical implications are discussed, and the paper outlines several avenues for future research.},
	keywords = {contributors, developers, freshmeat, license analysis, licensing, metadata, popularity, restrictive, users},
	isbn = {0-7695-2268-8-7},
	doi = {http://dx.doi.org/10.1109/HICSS.2005.38},
	url = {http://dx.doi.org/10.1109/HICSS.2005.38},
	author = {Stewart, Katherine J. and Ammeter, Anthony P. and Maruping, Likoebe M.}
}
@conference {Twidale:2005:SBF:1062455.1062468,
	title = {Silver bullet or fool{\textquoteright}s gold: supporting usability in open source software development},
	booktitle = {Proceedings of the 27th international conference on Software engineering},
	series = {ICSE {\textquoteright}05},
	year = {2005},
	pages = {35{\textendash}35},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {At first glance it can look like Open Source Software development violates many, if not all, of the precepts of decades of careful research and teaching in Software Engineering. One could take a classic SE textbook and compare the activities elaborated and advocated in the various chapters with what is actually done in plain sight in the public logs of an OSS project in say SourceForge. For a Professor of Software Engineering this might make for rather depressing reading. Are the principles of SE being rendered obsolete? Has OSS really discovered Brooks{\textquoteright} Silver Bullet? Or is it just a flash in the pan or Fool{\textquoteright}s Gold.In this talk I will mainly look at one aspect of Open Source Development, the {\textquoteright}problem{\textquoteright} of creating usable interfaces, particularly for non-technical end-users. Any approach involves the challenge of how to coordinate distributed collaborative interface analysis and design, given that in conventional software development this is usually done in small teams and almost always face to face. Indeed all the methods in any HCI text just assume same-time same-place work and don{\textquoteright}t map to distributed work, let alone the looser mechanisms of OSS development. Instead what is needed is a form of participatory usability involving the coordination of end users and developers in a constantly evolving redesign process.},
	keywords = {course project, education, lifecycle model, pedagogical, software engineering education, software process},
	isbn = {1-58113-963-2},
	doi = {10.1145/1062455.1062468},
	url = {http://doi.acm.org/10.1145/1062455.1062468},
	author = {Twidale, Michael}
}
@mastersthesis {43,
	title = {The social construction of freedom in free and open source software: Hackers, ethics, and the liberal tradition},
	volume = {PhD},
	year = {2005},
	school = {University of Chicago},
	type = {PhD Dissertation},
	address = {Chicago, Illinois},
	abstract = {This dissertation, based on fieldwork conducted between January 2001 and May 2003 on the Debian free software project and among hackers living in the Bay area, is an ethnography focused on the ethics and politics of free and open source hackers. My aim in this dissertation is to evaluate the rise of expressive rights among hackers as a historically and culturally specific practice of liberal freedom that can only be made sensible through the lens of a hacker technical way of life--in which their pragmatics and poetics are given serious consideration. Moving and integrating various levels of analysis: the phenomenology of technical praxis, the sociological creation of an ethical practice that unfolds in the hacker public sphere and the FOSS project, and the historical rise of reflective signification through overt political dissent, I offer a comprehensive account of how hackers have come to value and enact freedom, what they mean by it, and suggest some ideas about the broader political effects of their practices. Instead of an emphasis of self-determination and individuality based on the acquisition of property, hackers have placed emphasis on individuality as a form of critical self-determination that requires unrestricted access to knowledge in order to constantly develop technical skills and to progress the state of their technical art. Important for the purposes of this dissertation is that hackers challenge one sacred realm of liberal jurisprudence--intellectual property--by drawing on and reformulating ideals from another one--free speech.},
	keywords = {culture, hacker},
	author = {Coleman, E.G.}
}
@article {springerlink:10.1007/s10606-005-9000-1,
	title = {Socialization in an Open Source Software Community: A Socio-Technical Analysis},
	journal = {Computer Supported Cooperative Work (CSCW)},
	volume = {14},
	year = {2005},
	note = {"I present the results of my analyses of participation patterns in a particular OSS project, used as a case study: Python. More precisely, I use the Open Source Project Browser to qualitatively track and analyze the trajectories of several project members who evolved (or not) into full-fledged participants. This allows me to later discuss how socialization proceeds in an OSS community such as Python"

"Over the course of 2002, I progressively retrieved the entire email archive of python-dev (the developers{\textquoteright} mailing list) and the CVS source tree for the project. "

"I read the entirety of the messages written by these participants and also looked at the software code they produced. There were striking similarities between their progressions over time, which I will de- scribe shortly. Overall the trajectory of these participants reflects successful socialization in Python: an evolution from newcomer to developer."

http://www2.parc.com/csl/members/nicolas/documents/JCSCW-OSS.pdf},
	pages = {323-368},
	publisher = {Springer Netherlands},
	abstract = {Open Source Software (OSS) development is often characterized as a fundamentally new way to develop software. Past analyses and discussions, however, have treated OSS projects and their organization mostly as a static phenomenon. Consequently, we do not know how these communities of software developers are sustained and reproduced over time through the progressive integration of new members. To shed light on this issue I report on my analyses of socialization in a particular OSS community. In particular, I document the relationships OSS newcomers develop over time with both the social and material aspects of a project. To do so, I combine two mutually informing activities: ethnography and the use of software specially designed to visualize and explore the interacting networks of human and material resources incorporated in the email and code databases of OSS. Socialization in this community is analyzed from two perspectives: as an individual learning process and as a political process. From these analyses it appears that successful participants progressively construct identities as software craftsmen, and that this process is punctuated by specific rites of passage. Successful participants also understand the political nature of software development and progressively enroll a network of human and material allies to support their efforts. I conclude by discussing how these results could inform the design of software to support socialization in OSS projects, as well as practical implications for the future of these projects.},
	keywords = {cvs, developers, email, email archive, mailing list, open source project browser, participation, python, scm, source code, team, tools},
	issn = {0925-9724},
	url = {http://dx.doi.org/10.1007/s10606-005-9000-1},
	author = {DUCHENEAUT, NICOLAS}
}
@conference {Fielding:2005:SAO:1062455.1062474,
	title = {Software architecture in an open source world},
	booktitle = {Proceedings of the 27th international conference on Software engineering},
	series = {ICSE {\textquoteright}05},
	year = {2005},
	pages = {43{\textendash}43},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {In spite of the hype and hysteria surrounding open source software development, there is very little that can be said of open source in general. Open source projects range in scope from the miniscule, such as the thousands of non-maintained code dumps left behind at the end of class projects, dissertations, and failed commercial ventures, to the truly international, with thousands of developers collaborating, directly or indirectly, on a common platform. One characteristic that is shared by the largest and most successful open source projects, however, is a software architecture designed to promote anarchic collaboration through extensions while at the same time preserving centralized control over the interfaces. This talk features a survey of the state-of-the-practice in open source development in regards to software architecture, with particular emphasis on the modular extensibility interfaces within several of the most successful projects, including Apache httpd, Eclipse, Mozilla Firefox, Linux kernel, and the World Wide Web (which few people recognize as an open source project in itself). These projects fall under the general category of collaborative open source software development, which emphasizes community aspects of software engineering in order to compensate for the often-volunteer nature of core developers and take advantage of the scalability obtainable through Internet-based virtual organizations.},
	keywords = {apache, collaborative open source development, eclipse, extensibility, Firefox, linux, linux kernel, loose coupling, modularity, mozilla, open source, software architecture},
	isbn = {1-58113-963-2},
	doi = {10.1145/1062455.1062474},
	url = {http://doi.acm.org/10.1145/1062455.1062474},
	author = {Roy T. Fielding}
}
@conference {Hawthorne:2005:SEE:1062455.1062581,
	title = {Software engineering education in the era of outsourcing, distributed development, and open source software: challenges and opportunities},
	booktitle = {Proceedings of the 27th international conference on Software engineering},
	series = {ICSE {\textquoteright}05},
	year = {2005},
	pages = {643{\textendash}644},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {As software development becomes increasingly globally distributed, and more software functions are delegated to common open source software (OSS) and commercial off-the-shelf (COTS) components, practicing software engineers face significant challenges for which current software engineering curricula may leave them inadequately prepared. A new multi-faceted distributed development model is emerging that effectively commoditizes many development activities once considered integral to software engineering, while simultaneously requiring practitioners to apply engineering principles in new and often unfamiliar contexts. We discuss the challenges that software engineers face as a direct result of outsourcing and other distributed development approaches that are increasingly being utilized by industry, and some of the key ways we need to evolve software engineering curricula to address these challenges.},
	keywords = {computer science education, contextual learning, education, informatics, software engineering education},
	isbn = {1-58113-963-2},
	doi = {10.1145/1062455.1062581},
	url = {http://doi.acm.org/10.1145/1062455.1062581},
	author = {Hawthorne, Matthew J. and Perry, Dewayne E.}
}
@conference {783,
	title = {Unreliable Collaborators: Coordination in distributed volunteer teams},
	booktitle = {OSS2005: Open Source Systems },
	year = {2005},
	pages = {305-306},
	abstract = {Drawing together the interest, skills and resources of individuals to pursue productive activity is the cornerstone of wealth creation. Recently, new forms of productive activity have emerged that draw together highly motivated, often volunteer, participants to collaborate through low-cost information systems to produce high quality products that rival those produced by wealthy firms and markets. Examples include free (libr{\^A}{\textasciiacute}e) and open source software (FLOSS), such as Linux, and collaboratively edited texts, such as Wikipedia and the Open Directory. There is an opportunity to study these novel activities, to understand their organization, in order to both further their continued success and to assess whether and which of their novel organization techniques might be used in wider domains of human collaborative activity.},
	keywords = {coordination, floss organization, MOTIVATION, open source, volunteer teams},
	url = {http://pascal.case.unibz.it/handle/2038/1552},
	author = {Howison, James}
}
@conference {Kim:2005:UCG:1083142.1083146,
	title = {Using a clone genealogy extractor for understanding and supporting evolution of code clones},
	booktitle = {Proceedings of the 2005 international workshop on Mining software repositories},
	series = {MSR {\textquoteright}05},
	year = {2005},
	pages = {17-23},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {Programmers often create similar code snippets or reuse existing code snippets by copying and pasting. Code clones {\textemdash}syntactically and semantically similar code snippets{\textemdash}can cause problems during software maintenance because programmers may need to locate code clones and change them consistently. In this work, we investigate (1) how code clones evolve, (2) how many code clones impose maintenance challenges, and (3) what kind of tool or engineering process would be useful for maintaining code clones.
Based on a formal definition of clone evolution, we built a clone genealogy tool that automatically extracts the history of code clones from a source code repository (CVS). Our clone genealogy tool enables several analyses that reveal evolutionary characteristics of code clones. Our initial results suggest that aggressive refactoring may not be the best solution for all code clones; thus, we propose alternative tool solutions that assist in maintaining code clones using clone genealogy information.},
	keywords = {clone, clone detection, cvs, developers, evolution, maintenance, refactoring, source code},
	isbn = {1-59593-123-6},
	doi = {http://doi.acm.org/10.1145/1082983.1083146},
	url = {http://doi.acm.org/10.1145/1082983.1083146},
	attachments = {https://flosshub.org/sites/flosshub.org/files/17Using.pdf},
	author = {Kim, Miryung and Notkin, David}
}
@conference {778,
	title = {Using Plone To Support Collaborative Research},
	booktitle = {OSS2005: Open Source Systems },
	year = {2005},
	pages = {296-297},
	keywords = {collaboration environment, collaborative research, content management system, open source, plugin},
	url = {http://pascal.case.unibz.it/handle/2038/1558},
	author = {Adams, Paul and Nutter, David and Rank, Stephen and Boldyreff, Cornelia}
}
@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}
}
@booklet {Lopez-Fernandez_applyingsocial,
	title = {Applying Social Network Analysis to the Information in CVS Repositories},
	howpublished = {International Workshop on Mining Software Repositories (MSR 2004)},
	year = {2004},
	pages = {101-105},
	abstract = {The huge quantities of data available in the CVS repositories of large, long-lived libre (free, open source) software projects, and the many interrelationships among those data offer opportunities for extracting large amounts of valuable information about their structure, evolution and internal processes. Unfortunately, the sheer volume of that information renders it almost unusable without applying methodologies which highlight the relevant information for a given aspect of the project. In this paper, we propose the use of a well known set of methodologies (social network analysis) for characterizing libre software projects, their evolution over time and their internal structure. In addition, we show how we have applied such methodologies to real cases, and extract some preliminary conclusions from that experience.},
	keywords = {apache, complex networks, cvs, gnome, kde, libre software engineering, source code, source code repositories, visualization techniques, vizualization},
	attachments = {https://flosshub.org/sites/flosshub.org/files/101ApplyingSocial.pdf},
	author = {L{\'o}pez-Fern{\'a}ndez, L. and Gregorio Robles and Jesus M. Gonzalez-Barahona}
}
@proceedings {1191,
	title = {Collaboration, Leadership, Control, and Conflict Negotiation in the Netbeans.org Community},
	year = {2004},
	pages = {48-52},
	abstract = {Large open source software development communities are quickly learning that, to be successful, they must integrate efforts not only among the organizations investing developers within the community and unaffiliated volunteer contributors, but also negotiate relationships with external groups hoping to sway the social and technical direction of the community and its products. Leadership and control sharing across organizations and individuals in and between communities are common sources of conflict. Such conflict often leads to breakdowns in collaboration. This paper seeks to explore the negotiation of these conflicts, collaborative efforts, and leadership and control structures in the Netbeans.org community.},
	keywords = {conflict, leadership, netbeans},
	attachments = {https://flosshub.org/sites/flosshub.org/files/jensen_0.pdf},
	author = {Chris Jensen and Walt Scacchi}
}
@proceedings {1188,
	title = {Communication and Conflict Issues in Collaborative Software Research Projects},
	year = {2004},
	pages = {14-17},
	abstract = {The Open Source Component Artefact Repository (OSCAR) was developed under the auspices of the GENESIS project to store data produced during the software development process. Significant problems were encountered during the course of the project in both the development itself and management of the project. The reasons for and potential solutions to these problems are examined with the intention of developing a set of guidelines to enable participants in other collaborative projects to avoid these pitfalls.
We wish to make it clear that we attach no opprobrium to any of the participants in the GENESIS project as many of the issues we outline below have solutions only visible with hindsight. Instead, we seek to provide a fair-minded critique of our role and the mistakes we made in a fairly typical two-year EU research project, and to provide a set of recommendations for other similar projects, in order that they can (attempt to) avoid suffering similarly.},
	keywords = {artefact, cvs, genesis, oscar},
	attachments = {https://flosshub.org/sites/flosshub.org/files/boldyreff15-18.pdf},
	author = {Boldyreff, Cornelia and Nutter, David and Rank, Stephen}
}
@proceedings {1190,
	title = {Community structure of modules in the Apache project},
	year = {2004},
	pages = {44-48},
	abstract = {The relationships among modules in a software project of a certain size can give us much information about its internal organization and a way to control and monitor development activities and evolution of large libre software projects. In this paper, we show how information available in CVS repositories can be used to study the structure of the modules in a project when they are related by the people working in them, and how techniques taken from the social networks fields can be used to highlight the characteristics of that structure. As a case example, we also show some results of applying this methodology to the Apache project in several points in time. Among other facts, it is shown how the project evolves and is self-structuring, with developer communities of modules corresponding to semantically related families of modules.},
	keywords = {apache, cvs, source code},
	attachments = {https://flosshub.org/sites/flosshub.org/files/gonzalezBarahona44-48.pdf},
	author = {Jesus M. Gonzalez-Barahona and Luis Lopez and Gregorio Robles}
}
@proceedings {1202,
	title = {Control Objectives in Open Source Projects},
	year = {2004},
	pages = {100-104},
	abstract = {Many studies on Open Source Software Development (OSSD) have been published in the past years. In these studies, OSSD has received positive comments and is proposed as a new way of developing software. We investigate how project management is used in Open Source Software (OSS) projects to exercise control of development activities. Project management in OSSD is worth studying, because research has shown that project management is a critical success factor in traditional software development. We use the COBIT framework to audit project management practices commonly found in OSS projects with the aim of determining which practices are currently missing or can be further improved upon. The framework identifies several potential threats to the long term continuity of OSS projects.},
	keywords = {cobit, project management},
	attachments = {https://flosshub.org/sites/flosshub.org/files/ven101-105.pdf},
	author = {Ven, Kris and Verelst, Jan}
}
@conference {Crowston:2004,
	title = {Coordination practices for bug fixing within FLOSS development teams},
	booktitle = {1st International Workshop on Computer Supported Activity Coordination, 6th International Conference on Enterprise Information Systems},
	year = {2004},
	note = {"First, we chose projects for which data we need for our analysis are publicly available (not all projects allow public access to the bug tracking system). Second, we chose teams with more than 8 members...we tried to select more and less suc- cessful development teams. To this aim we used the definitions of success proposed by [9], who suggest that a project is successful if it is active, the resulting software is downloaded and used and the code matures"

"Kicq, Gaim and PhPmyAdmin were chosen" - effective
DynAPI was chosen as an example of a less effective project" 

"We collected data indicative of the success of each project, such as its level of activity, number of downloads and development status. We then collected data from the archives of the bug tracking system, the tool used to support the bug fixing process"},
	address = {Porto, Portugal},
	abstract = {Free/Libre Open Source Software (FLOSS) is primarily developed by distributed teams. Developers contribute from around the world and coordinate their activity almost exclusively by means of email and bulletin boards. FLOSS development teams some how profit from the advantages and evade the challenges of distributed software development. Despite the relevance of the FLOSS both for research and practice, few studies have investigated the work practices adopted by these development teams. In this paper we investigate the structure and the coordination practices adopted by development teams during the bug-fixing process, which is considered one of main areas of FLOSS project success. In particular, based on a codification of the messages recorded in the bug tracking system of four projects, we identify the accomplished tasks, the adopted coordination mechanisms, and the role undertaken by both the FLOSS development team and the FLOSS community. We conclude with suggestions for further research.},
	keywords = {activity, bug fixing, bug reports, bug tracker, coordination, downloads, dynapi, FLOSS, gaim, kicq, phpmyadmin, status},
	attachments = {https://flosshub.org/sites/flosshub.org/files/CrowstonScozzi04coordination.pdf},
	author = {Kevin Crowston and Barbara Scozzi}
}
@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 {capiluppi:23,
	title = {Improving comprehension and cooperation through code structure},
	journal = {IEE Seminar Digests},
	volume = {2004},
	number = {908},
	year = {2004},
	note = {"In this study we measured source code size in three different forms (LOCs, SLOCs, and Kbs of code)."

"Pilot Project: The ARLA System"
},
	pages = {23-28},
	publisher = {IEE},
	abstract = {Defining a relationship between a software system{\textquoteright}s architecture and the process{\textquoteright} efforts is one of the most fascinating questions of software engineering. Apparently, when a system{\textquoteright}s architecture is complex, the process to improve and evolve it will be more difficult. We try to tackle this question from a different point of view: given an open source system, in all the phases of its evolution, we focus on both the aspects of software developers, and the obtained software product. More we observe one of the possible architectures of this system, based on the tree structure derived from source components. First conclusions show that some patterns of tree evolution are recognizable: some branches may appear more promising than other, and are extensively evolved, while other remains in the same status for all the life cycle. More, when the tree structure reaches some status, the process of joining as a core developer seems to forestall. },
	keywords = {arla, code structure, contributors, developers, open source system, scm, software development, software engineering, software process, software product, software system architecture, source code, source components, tree evolution, tree structure},
	doi = {10.1049/ic:20040260},
	url = {http://link.aip.org/link/abstract/IEESEM/v2004/i908/p23/s1},
	attachments = {https://flosshub.org/sites/flosshub.org/files/capiluppi2004.pdf},
	author = {A. Capiluppi}
}
@conference {1054,
	title = {LASER: a lexical approach to analogy in software reuse},
	booktitle = {International Workshop on Mining Software Repositories (MSR 2004)},
	volume = {2004},
	year = {2004},
	pages = {112 - 116},
	publisher = {IEE},
	organization = {IEE},
	address = {Edinburgh, Scotland, UK},
	abstract = {Software reuse is the process of creating a software system from existing software components, rather than creating it from scratch. With the increase in size and complexity of existing software repositories, the need to provide intelligent support to the programmer becomes more pressing. An analogy is a comparison of certain similarities between things which are otherwise unlike. This concept has shown to be valuable in developing UML-level reuse techniques. In the LASER project we apply lexically-driven Analogy at the code level, rather than at the UML-level, in order to retrieve matching components from a repository of existing components. Using the lexical ontology Word-Net, we have conducted a case study to assess if class and method names in open source applications are used in a semantically meaningful way. Our results demonstrate that both hierarchical reuse and parallel reuse can be enhanced through the use of lexically-driven Analogy.},
	keywords = {class, developers, functions, jrefactory, method, naming, natural language, reuse, source code, wordnet},
	doi = {10.1049/ic:20040487},
	attachments = {https://flosshub.org/sites/flosshub.org/files/112LASER.pdf},
	author = {Amin, R. and Mel O Cinneide and Veale, Tony}
}
@article {DBLP:journals/electronicmarkets/Joode04,
	title = {Managing Conflicts in Open Source Communities},
	journal = {Electronic Markets},
	volume = {14},
	number = {2},
	year = {2004},
	pages = {104-113},
	abstract = {An increasing number of companies adopt open source software. These companies will typically pay programmers to participate in the design, development and maintenance of open source software. The programmers, however, are reported to have different interests compared to the voluntary programmers who dominate most open source communities. The diversity of interest will inevitably result in conflicts. To ensure that their interests are achieved, companies should understand how conflicts between their programmers and the voluntary programmers can be managed. The aim of this paper is to identify and discuss mechanisms that are currently present to manage conflicts in open source communities.

The mechanisms identified in this paper are based on an explorative literature study and on 48 semi-structured interviews with programmers from a variety of open source communities. Four mechanisms have been identified and their relevance in the management of conflicts are discussed. They are: third-party intervention; modularity; parallel software development lines; and the exit option. The paper ends with an example of Covalent, which deploys parallel software development lines to manage conflicts in the Apache community. },
	keywords = {abiword, apache, conflict, covalent, interviews, organizational sponsorship, Volunteers},
	author = {Ruben van Wendel de Joode}
}
@article {1253,
	title = {The many meanings of open source},
	journal = {IEEE Software},
	volume = {21},
	year = {2004},
	note = {"We determined a set of characteristics that are almost always present and others that vary among open source projects, and this serves as the core of this work"
"Section 3 describes some open source characteristics that can be used in determining whether a project is or not open source"},
	month = {01/2004},
	pages = {34 - 40},
	abstract = {The term Open Source is widely applied to describe some software development methodologies. This paper does not provide a judgment on the open source approach, but exposes the fact that simply stating that a project is open source does not provide a precise description of the approach used to support the project. By taking a multi- disciplinary point of view, we propose a collection of characteristics that are common, as well as some that vary among open source projects. The set of open source characteristics we found can be used as a tick-list both for analysing and for setting up open source projects. Our tick-list also provides a starting point for understanding the many meanings of the term open source.},
	keywords = {classification, projects, taxonomy},
	issn = {0740-7459},
	doi = {10.1109/MS.2004.1259206},
	attachments = {https://flosshub.org/sites/flosshub.org/files/gacek.pdf},
	author = {Gacek, C. and Arief, B.}
}
@conference {Germ04b,
	title = {Mining CVS repositories, the softChange experience},
	booktitle = {Proc. Int{\textquoteright}l Workshop on Mining Software Repositories ({MSR})},
	year = {2004},
	note = {"Mailing lists. Mailing lists are an important source of information about the evolution of the project. We currently correlate MRs [modification requests] to mail messages by using the author and the date attributes of both the MR and the message."},
	pages = {17{\textendash}21},
	abstract = {CVS logs are a rich source of software trails (information left behind by the contributors to the development process, usually in the forms of logs). This paper describes how softChange extracts these trails, and enhances them. This paper also addresses some challenges that CVS fact extraction poses to researchers.},
	keywords = {bugzilla, cvs, email archives, log files, logs, softchange},
	attachments = {https://flosshub.org/sites/flosshub.org/files/17MiningCVS.pdf},
	author = {German, Daniel}
}
@conference {1050,
	title = {Mining version control systems for FACs (frequently applied changes)},
	booktitle = {International Workshop on Mining Software Repositories (MSR 2004)},
	volume = {2004},
	year = {2004},
	pages = {48 - 52},
	publisher = {IEE},
	organization = {IEE},
	address = {Edinburgh, Scotland, UK},
	abstract = {Today, programmers are forced to maintain a software system based on their gut feeling and experience. This paper makes an attempt to turn the software maintenance craft into a more disciplined activity, by mining for frequently applied changes in a version control system. Next to some initial results, we show how this technique allows to recover and study successful maintenance strategies, adopted for the redesign of long{\textendash}lived systems.},
	keywords = {ccfinder, change analysis, change history, clone, clone detection, cvs, maintenance, tomcat, version control},
	doi = {10.1049/ic:20040475},
	attachments = {https://flosshub.org/sites/flosshub.org/files/48MiningVersion.pdf},
	author = {Van Rysselberghe, F. and Demeyer, S}
}
@article {Chen:2004:OCL:990374.990391,
	title = {Open-Source Change Logs},
	journal = {Empirical Softw. Engg.},
	volume = {9},
	year = {2004},
	note = {"We decided to compare actual differences in the source code with entries in the ChangeLog file. We used lxr, the Linux cross-referencing tool..., to determine the precise differences between two successive software versions. We then compared these differences with the records in the ChangeLog file to check the completeness of the ChangeLog file."
},
	month = {September},
	pages = {197{\textendash}210},
	publisher = {Kluwer Academic Publishers},
	address = {Hingham, MA, USA},
	abstract = {A recent editorial in Empirical Software Engineering suggested that open-source software projects offer a great deal of data that can be used for experimentation. These data not only include source code, but also artifacts such as defect reports and update logs. A common type of update log that experimenters may wish to investigate is the ChangeLog, which lists changes and the reasons for which they were made. ChangeLog files are created to support the development of software rather than for the needs of researchers, so questions need to be asked about the limitations of using them to support research. This paper presents evidence that the ChangeLog files provided at three open-source web sites were incomplete. We examined at least three ChangeLog files for each of three different open-source software products, namely, GNUJSP, GCC-g++, and Jikes. We developed a method for counting changes that ensures that, as far as possible, each individual ChangeLog entry is treated as a single change. For each ChangeLog file, we compared the actual changes in the source code to the entries in the ChangeLog file and discovered significant omissions. For example, using our change-counting method, only 35 of the 93 changes in version 1.11 of Jikes appear in the ChangeLog file{\textemdash}that is, over 62\% of the changes were not recorded there. The percentage of omissions we found ranged from 3.7 to 78.6\%. These are significant omissions that should be taken into account when using ChangeLog files for research. Before using ChangeLog files as a basis for research into the development and maintenance of open-source software, experimenters should carefully check for omissions and inaccuracies.},
	keywords = {change log, gcc, GCC-g, GNUJSP, Jikes, log files, Open-source software, source code},
	issn = {1382-3256},
	doi = {10.1023/B:EMSE.0000027779.70556.d0},
	url = {http://portal.acm.org/citation.cfm?id=990374.990391},
	attachments = {https://flosshub.org/sites/flosshub.org/files/chen.pdf},
	author = {Chen, Kai and Schach, Stephen R. and Yu, Liguo and Offutt, Jeff and Heller, Gillian Z.}
}
@article {1077,
	title = {Profiling an Open Source Project Ecology and Its Programmers},
	journal = {Electronic Markets},
	volume = {14},
	year = {2004},
	month = {6/2004},
	pages = {77 - 88},
	abstract = {While many successful and well-known open source projects produce output of high quality, a general assessment of this development paradigm is still missing. In this paper, an online community of both small and large, successful and failed projects and their programmers is analysed mainly using the version-control data of each project, also according to their productivity and estimation of expended effort. As the results show, there are indeed significant differences between this cooperative development model and the commercial organization of work in the areas explored. Both open source software projects in their size and their programmers{\textquoteright} effort differ significantly, and the evolution of projects{\textquoteright} size over time seems in part to contradict the laws of software evolution proposed for commercial systems. Both the inequality of effort distribution between programmers and an increasing number of developers in a project do not lead to a decrease in productivity, opposing Brooks{\textquoteright}s Law. Effort estimation based on the COCOMO model for commercial organizations shows a large amount of effort expended for the projects, while a more general Norden-Rayleigh modeling shows a distinctly smaller expenditure. This proposes that either a highly efficient development is achieved by this self-organizing cooperative and highly decentralized form of work, or that the participation of users besides programming tasks is enormous and constitutes an economic factor of large proportions. },
	keywords = {affiliation network, brooks law, cocomo, effort estimation, evolution, productivity, project success, scm, size, time, version control},
	issn = {1422-8890},
	doi = {10.1080/10196780410001675031},
	author = {Koch, Stefan}
}
@article {1113,
	title = {Release criteria for the Linux kernel},
	journal = {First Monday},
	volume = {9},
	number = {4},
	year = {2004},
	note = {"The first was to examine the change logs [10, 11, 12] that are submitted with the public release of a version of the kernel on www.kernel.org [1]. Observations were made on the release nomenclature used in both the 2.4.x series and the 2.5.x (which later became the 2.6.x series). The number of patches incorporated into each release and the elapsed time between releases was recorded. The second approach was to review the Linux kernel mailing list [2] for any evidence of criteria for performing a particular release including any metrics used, tests carried out or bug databases referenced."},
	month = {2004},
	abstract = {Before software is released to its users, software developers will ensure that the software has met specified functional and technical requirements and that it is as free from bugs as possible. Users should be able to have a high degree of confidence that the software will perform as specified and without fault. With open source development practices such as those employed on the Linux kernel project, there are no detailed specifications and little formal testing processes. The questions, then, are what criteria, if any, are used in determining the suitability for release of a particular version of this software, and do users have any degree of confidence in the quality of that release of software? These questions were examined in this study using information from the Linux Kernel Mailing List (LKML), the primary forum for discussion of development issues of the Linux kernel, and change logs submitted with version releases of the Linux kernel. It was determined that very little planning is employed in determining the release of a particular version of the software and that a version of the software is essentially a collection of source patches released at regular intervals with some stabilisation of the code base before each release. Very little attempt is made to verify that the code is bug free, and consequently, the code released is of a largely unknown level of quality. End users are left to decide for themselves the suitability and robustness of a particular version of the software.},
	keywords = {bugs, change log, linux, linux kernel, log files, mailing list, patches, quality, release history},
	url = {http://firstmonday.org/htbin/cgiwrap/bin/ojs/index.php/fm/article/view/1136/1056},
	attachments = {https://flosshub.org/sites/flosshub.org/files/Glance.pdf},
	author = {Glance, D.G.}
}
@article {DBLP:journals/electronicmarkets/VemuriB04,
	title = {Will the Open Source Movement Survive a Litigious Society?},
	journal = {Electronic Markets},
	volume = {14},
	number = {2},
	year = {2004},
	pages = {114-123},
	abstract = {Since no one is willing to undertake costly research and development to create innovation, incentives in the form of patents were instituted to motivate R\&D. In software development, contrary to economic intuition, open source software has emerged as a viable alternative source of innovation. The patenting system has performed reasonably well in enhancing many other technologies. Since the mid-1990s patenting of software and business methods is increasingly accepted in the United States. The legitimacy of many of these new patents is subject to controversy and debate. In this paper we examine the trend, rate of litigation and disposition of US patents in the US Federal Courts. We find that litigation rates of software and business method patents is four times that of all other patents and is increasing. A majority of patent litigations are not won by the perpetrator of the lawsuits. The open source software community is not immune to heightened patent litigations. Since software development is incremental, the paths of OSS and commercial development are entwined. The spillover of patent litigation into OSS may have disastrous consequences: It may increase the {\textquoteright}cost{\textquoteright} of OSS, dissuade volunteer developers and make OSS less attractive to users. },
	keywords = {courts, INNOVATION, lawsuit, litigation, patents, software patents},
	author = {Vijay K. Vemuri and Vince Bertone}
}
@conference {German03automatingthe,
	title = {Automating the measurement of open source projects},
	booktitle = {Proceedings of the 3rd Workshop on Open Source Software Engineering},
	year = {2003},
	note = {"We have chosen to use Evolution to illustrate some of the capabilities of SoftChange. We focus on the data provided by CVS logs and the CVS commit mailing list. Our data includes changes to the CVS repository from April 1998 to January 2003."},
	pages = {63{\textendash}67},
	abstract = {The proliferation of open source projects raises a number of vital economic, social, and software engineering questions that are subject of intense research. Based on experience analyzing numerous open source and commercial projects we propose a set of tools to support extraction and validation of software project data. Such tools would streamline empirical investigation of open source projects and make it possible to test existing and new theories about the nature of open source projects. Our soft- ware includes tools to extract and summarize information from mailing lists, CVS logs, ChangeLog files, and defect tracking databases. More importantly, it cross-links records from various data sources and identifies all contributors for a software change. We illustrate some of the capabilities by analyzing data from Ximian Evolution project.},
	keywords = {bug reports, bug tracking, changelog, cvs, defects, evolution, log files, logs, mailing list, scm, softchange, source code, ximian, ximian evolution},
	attachments = {https://flosshub.org/sites/flosshub.org/files/germanMockus2003.pdf},
	author = {German, Daniel and Audris Mockus}
}
@article {Reinke2003707,
	title = {The availability of source code in relation to timely response to security vulnerabilities},
	journal = {Computers \& Security},
	volume = {22},
	number = {8},
	year = {2003},
	note = {"This paper considers the effects of proprietary software versus non-proprietary software in determining the speed with which a security fix is made available"
"The sources considered are the BugTraq mailing list (available at SecurityFocus.com), the CERT Coordination Center (www.cert.org), and Incidents.org (from the SANS Institute)"
Note that these lists are generic topical discussion lists and not the mailing lists OF a particular open source project.},
	pages = {707 - 724},
	abstract = {Once a vulnerability has been found in an application or service that runs on a computer connected to the Internet, fixing that exploit in a timely fashion is of the utmost importance. There are two parts to fixing vulnerability: a party acting on behalf of the application{\textquoteright}s vendor gives instructions to fix it or makes a patch available that can be downloaded; then someone using that information fixes the computer or application in question. This paper considers the effects of proprietary software versus non-proprietary software in determining the speed with which a security fix is made available, since this can minimize the amount of time that the computer system remains vulnerable.},
	keywords = {bugtraq, cert, email, email archives, mailing list, security, vulnerability},
	issn = {0167-4048},
	doi = {DOI: 10.1016/S0167-4048(03)00011-7},
	url = {http://www.sciencedirect.com/science/article/B6V8G-4B9CV31-C/2/a218fccfaef185af5c122f118b252703},
	author = {John Reinke and Hossein Saiedian}
}
@conference {DBLP:conf/ecis/TsiavosH03,
	title = {Beyond good and evil: why open source development for peer-to-peer networks does not necessarily equal to an open society is as imbalanced as copyright law and definitely is not going to make you a better person},
	booktitle = {European Conference on Information Systems (ECIS 2003)},
	year = {2003},
	note = {"In a first stage we collected data related to the development of the Gnutella protocol. The sources included: web sites that were used for hosting forums and file repositories related to the development of the protocol that could be either archived or still operational; messages posted on discussion groups, forums and newsgroups; the design documents of the Gnutella protocol.
In a second stage we gathered material related to the Limewire application. The sources included: operational and archived web sites having been used for the development of the application; applications such as Concurrent Version Systems (CVS) or Bug reporting tools (such as Issuezila), design and implementation documentation and relevant press reports.
The data gathered covered a time span from early 2000 to late November 2002."
"Other sources informed our research and also acted, at times of uncertainty, as forms of triangulation and verification (Lee 1991). These sources include websites such as Slashdot.org and WiredNews; IRC-mediated communications and private messages exchanged between the various developers."},
	month = {2003},
	abstract = {This paper interrogates the claims that open source development is an ideal form of regulatory development. We begin by presenting the literature that offers a framework of modalities of regulation where code, along with laws, markets, and norms shape and influence individual action. Within this framework, it is argued that for an Open Society we need Open Code.	We present the processes through which the Gnutella protocol and the Limewire application are developed by deconstructing the mechanisms of participation and contribution of the individual developers. The techniques of monitoring, modularization and filtering that we identify appear to be inconsistent with open society promises. Instead we suggest a different framing, that of creating nests of interests, whose creators can find refuge from inhabitants of other nests. From that perspective, we suggest that we should stop referring to the war between Copyright and peer-to-peer networks as the battle between good and evil.},
	keywords = {bug reports, cvs, design documents, discussion, discussion forums, documentation, forums, gnutella, issuezilla, limewire, web site},
	attachments = {https://flosshub.org/sites/flosshub.org/files/tsiavosHosein.pdf},
	author = {Prodromos Tsiavos and Ian Hosein}
}
@article {146,
	title = {Community, joining, and specialization in open source software innovation: a case study},
	journal = {Research Policy},
	volume = {32},
	number = {7},
	year = {2003},
	note = {first, telephone interviews
"Secondly, we collected the project{\textquoteright}s public email conversations stored in the projects{\textquoteright} 
mailing lists which is archived on Freenet{\textquoteright}s website"
"The third source of data included the history of changes to the software code available 
via the project{\textquoteright}s software repository within the CVS ({\textquoteleft}Concurrent Versioning System{\textquoteright}) source 
code management tool"
"Fourthly, in order obtain contextual understanding of the project we collected publicly 
available documents related to open source in general and to the project in particular. Among 
the most important sources were the Freenet project web pages (e.g. the Frequently Asked 
Questions (FAQ)7), Ian Clarke{\textquoteright}s master thesis (1999), newspaper interviews with the core 
developers, and a technical paper (Clarke, Sandberg, Wiley, \& Hong, 2000) describing the 
Freenet project written by some of the developers."},
	pages = {1217-1241},
	abstract = {This paper develops an inductive theory of the open source software innovation process by focussing on the creation of Freenet, a project aimed at developing a decentralized and anonymous peer-to-peer electronic file sharing network. We are particularly interested in the strategies and processes by which new people join the existing community of software developers, and how they initially contribute code. Analyzing data from multiple sources on the Freenet software development process, we generate the constructs of "joining script", We are grateful to helpful comments from two anonymous reviewers. We also thank Chris Argyris, John Seely Brown, Eric von Hippel, Stefan Haefliger, Petra Kugler, Heike Bruch, Simon Gchter, Simon Peck, and Hari Tsoukas for helpful comments and suggestions. Ben Ho and Craig Lebowitz provided technical assistance with data importation and parsing. We would like to thank Ian Clarke and the Freenet developers for their willingness to participate in our study and providing key insights into the open source development process. Karim R. Lakhani would like to acknowledge the generous support of The Boston Consulting Group and Canada{\textquoteright}s Social Science and Humanities Research Council doctoral fellowship. Georg von Krogh and Sebastian Spaeth acknowledge the generous support from the Research Foundation at the University of St. Gallen.},
	keywords = {cvs, email, email archives, freenet, INNOVATION, mailing lists, roles, source code},
	doi = {http://dx.doi.org/10.1016/S0048-7333(03)00050-7},
	attachments = {https://flosshub.org/sites/flosshub.org/files/krogh03.pdf},
	author = {Georg von Krogh and Spaeth, S. and Karim R Lakhani}
}
@conference {1109,
	title = {Distributed Collective Practices and F/OSS Problem Management: Perspective and Methods},
	booktitle = {Conference on Cooperation, Innovation \& Technology (CITE 2003)},
	year = {2003},
	note = {"We have begun studying in detail the general issues raised above using a large collection of research data from the Mozilla project"
"Our Bugzilla snapshot contains over 128,000 problem reports, of which about 88,000 have been resolved"},
	abstract = {This paper presents the state of our research on Distributed Collective Practices (DCPs) in Free/Open-Source Software (F/OSS) projects, focusing on sensemaking and resolution of software problems. We are exploring the hypothesis that variations in the content and in the articulation of these socio-technical processes have an impact on the outcome of the activity of F/OSS collectives, and more specifically on problem resolution. Our preliminary techniques for combining qualitative data analysis with automated process extraction result in a scalable analysis method called Computational Amplification (CA). We are applying CA to 128,000 problem reports from the Mozilla F/OSS project. The paper illustrates how CA is used to create multidimensional process models and shows types of conclusions we can reach.},
	keywords = {Automated process extraction, bug fixing, bug reports, bugzilla, Collective knowledge management, Information extraction from natural language texts, mozilla, Software problem management},
	author = {Gasser, Les and Gabriel Ripoche}
}
@article {1099,
	title = {Evidences in the evolution of OS projects through Changelog Analyses},
	journal = {Proceedings of the 3rd ICSE Workshop on Open Source},
	year = {2003},
	note = {"In this study we concentrate on a very large sample (406 projects) selected randomly from an OS portal[20]" (freshmeat)

"We define three clusters of projects: {\textquoteright}large{\textquoteright} projects as long as they are based on more than 1000KB(40KLOC)..."},
	pages = {19-24},
	abstract = {Most empirical studies about Open Source (OS) projects or products are vertical and usually deal with the flagship, successful projects. There is a substantial lack of horizontal studies to shed light on the whole population of projects, including failures. This paper presents a horizontal study aimed at characterizing OS projects. We analyze a sample of around 400 projects from a popular OS project repository. Each project is characterized by a number of attributes. We analyze these attributes statically and over time. The main results show that few projects are capable of attracting a meaningful community of developers. The majority of projects is made by few (in many cases one) person with a very slow pace of evolution. We then try to observe how many projects count on a substantial number of developers, and analyze those projects more deeply. The goal is to achieve a better insight in the dynamics of open source development. The initial results of this analysis, especially growth in code size and tendency to stability in modularity, seem to be in line with traditional close source development.},
	keywords = {classification, freshmeat, loc, modularity, repository, size, sloc, source code},
	url = {http://hdl.handle.net/10552/1037},
	attachments = {https://flosshub.org/sites/flosshub.org/files/capiluppi2003.pdf},
	author = {Capiluppi, Andrea}
}
@article {2003,
	title = {From a Firm-Based to a Community-Based Model of Knowledge Creation: The Case of the Linux Kernel Development},
	journal = {Organization Science},
	volume = {14},
	number = {6},
	year = {2003},
	note = {"we study the Linux development community mainly by analyzing the artifacts that the Linux developers have produced. A key output of knowledge creation activities is the artifacts. The most important artifact, of course, is the Linux operating system source code."
"Along with the source code, a "Credits" text file and a "MAINTAINERS" text file are distributed to the users."
"An equally important artifact is the development activities archived in the Linux-kernel mailing list"..."Using the weekly Linux-kernel email archive for years 1995 to 2000 as a key source of data, we focus on people who have sent at least one email to the Linux-kernel mailing list. "
"In addition, we examine the developers{\textquoteright} demographic distributions, working patterns, and motivations by analyzing the raw data from an on-line survey"},
	pages = {pp. 633-649},
	publisher = {INFORMS},
	abstract = {We propose a new model of knowledge creation in purposeful, loosely coordinated, distributed systems, as an alternative to a firm-based one. Specifically, using the case of the Linux kernel development project, we build a model of community-based, evolutionary knowledge creation to study how thousands of talented volunteers, dispersed across organizational and geographical boundaries, collaborate via the Internet to produce a knowledge-intensive, innovative product of high quality. By comparing and contrasting the Linux model with the traditional/commercial model of software development and firm-based knowledge creation efforts, we show how the proposed model of knowledge creation expands beyond the boundary of the firm. Our model suggests that the product development process can be effectively organized as an evolutionary process of learning driven by criticism and error correction. We conclude by offering some theoretical implications of our community-based model of knowledge creation for the literature of organizational learning, community life, and the uses of knowledge in society.},
	keywords = {credits, developers, email, email archives, knowledge creation, linux kernel, mailing list, maintainers, scm, source code, Survey, Volunteers},
	issn = {10477039},
	url = {http://www.jstor.org/stable/4135125},
	author = {Lee, Gwendolyn K. and Cole, Robert E.}
}
@article {flosswp77,
	title = {Guarding the Commons: How Community Managed Software Projects Protect Their Work},
	journal = {Research Policy},
	volume = {32},
	year = {2003},
	note = {"Data was collected from three primary sources: 1) observation at project and user group meetings, technical presentations and conferences; 2) informant interviews; and 3) project data archived on the Internet that detailed project interactions and structural developments."

"Project data was collected from online archives and included documents such as: mission statements, charters, bylaws, meeting minutes, and mailing list archives."},
	month = {February},
	pages = {1179-1198},
	edition = {7},
	abstract = {Theorists often speculate why open source and free software project contributors give their work away. Although contributors make their work publicly available, they do not forfeit their rights to it. Community managed software projects protect their work by using several legal and normative tactics, which should not be conflated with a disregard for or neglect of intellectual property rights. These tactics allow a project?s intellectual property to be publicly and freely available and yet, governable. Exploration of this seemingly contradictory state may provide new insight into governance models for the management of digital intellectual property.},
	keywords = {Common Pool Resources, email, email archives, intellectual property, mailing list, open source, Public Goods, Software, Survey},
	attachments = {https://flosshub.org/sites/flosshub.org/files/rp-omahony.pdf},
	author = {Siobhan O{\textquoteright}Mahony}
}
@article {flosswp124,
	title = {Maintainability of the Linux Kernel},
	journal = {Proceedings of the 2nd Workshop on Open Source Software Engineering ICSE2002},
	year = {2003},
	note = {"We have examined 365 versions of Linux.  For every version, we counted the number of 
instances of common (global) coupling between each of the 17 kernel modules and all the other 
modules in that version of Linux."},
	month = {October},
	abstract = {We have examined 365 versions of Linux. For every version, we counted the number of instances of common (global) coupling between each of the 17 kernel modules and all the other modules in that version of Linux. We found that the number of instances of common coupling grows exponentially with version number. This result is significant at the 99.99\% level, and no additional variables are needed to explain this increase. We conclude that, unless Linux is restructured with a bare minimum of common coupling, the dependencies induced by common coupling will, at some future date, make Linux exceedingly hard to maintain without inducing regression faults.},
	keywords = {coupling, kernel, linux, linux kernel, modules, source code},
	attachments = {https://flosshub.org/sites/flosshub.org/files/linux-maint_0.pdf},
	author = {Schach, Stephen R. and Jin, B. and Wright, D.R.}
}
@article {1116,
	title = {Organizational learning in open-source software projects: an analysis of debugging data},
	journal = {IEEE Transactions on Engineering Management},
	volume = {50},
	year = {2003},
	month = {11/2003},
	pages = {485 - 493},
	abstract = {This paper studies organizational learning effects in open-source programming projects. Working with data from the Apache and Mozilla projects, the study focuses on three aspects of open-source development. The first is the use of the open-source approach as a hedge against system complexity. The second is the adaptive learning mechanisms realized by the debugging process. The last is the learning curve effects of project-specific experience on bug cycle times. The results indicate that while open-source development is subject to positive learning effects, these effects are not universal, with some projects deriving more benefit than others.},
	keywords = {apache, bugs, complexity, mozilla},
	issn = {0018-9391},
	doi = {10.1109/TEM.2003.820136},
	author = {Huntley, C.L.}
}
@conference {Ye:2003:TUM:776816.776867,
	title = {Toward an understanding of the motivation Open Source Software developers},
	booktitle = {Proceedings of the 25th International Conference on Software Engineering},
	series = {ICSE {\textquoteright}03},
	year = {2003},
	note = {"Analyzing the emails sent to the mailing fist is one way of understanding the structure of the community."
"Table 2 displays the number of code contributions made by members to the GIMP system and the defined roles of those contributing members. We counted the number of contributions made by each person by analyzing the change log of the system."},
	pages = {419{\textendash}429},
	publisher = {IEEE Computer Society},
	organization = {IEEE Computer Society},
	address = {Washington, DC, USA},
	abstract = {An Open Source Software (OSS) project is unlikely to be successful unless there is an accompanied community that provides the platform for developers and users to collaborate. Members of such communities are volunteers whose motivation to participate and contribute is of essential importance to the success of OSS projects. In this paper, we aim to create an understanding of what motivates people to participate in OSS communities. We theorize that learning is one of the motivational forces. Our theory is grounded in the learning theory of Legitimate Peripheral Participation, and is supported by analyzing the social structure of OSS communities and the co-evolution between OSS systems and communities. We also discuss practical implications of our theory for creating and maintaining sustainable OSS communities as well as for software engineering research and education.},
	keywords = {change log, COMMUNITY, contributions, contributors, developers, email, email archives, evolution, gimp, log files, mailing list, roles, source code},
	isbn = {0-7695-1877-X},
	url = {http://portal.acm.org/citation.cfm?id=776816.776867},
	attachments = {https://flosshub.org/sites/flosshub.org/files/YeKishida.pdf},
	author = {Ye, Yunwen and Kishida, Kouichi}
}
@conference {1160,
	title = {Adopting OSS Methods by Adopting OSS Tools},
	booktitle = {Proceedings of the 2nd ICSE Workshop on Open Source},
	year = {2002},
	abstract = {The open source movement has created and used a set of software engineering tools with features that fit the characteristics of open source development processes. To a large extent, the open source culture and methodology are conveyed to new developers via the toolset itself, and through the demonstrated usage of these tools on existing projects. The rapid and wide adoption of open source tools stands in stark contrast to the difficulties encountered in adopting traditional CASE tools. This paper explores the characteristics that make these tools adoptable and how adopting them may influence software development processes.},
	keywords = {ant, argouml, bugzilla, cactus, cvs, developers, eclipse, emacs, email, faq, junit, mailing lists, make, netbeans, package management, rpm, scarab, subversion, teams, tools, torque, WORK},
	attachments = {https://flosshub.org/sites/flosshub.org/files/Robbins.pdf},
	author = {Robbins, Jason E.}
}
@article {65,
	title = {Analyzing cloning evolution in the Linux kernel},
	journal = {Information and Software Technology},
	volume = {44},
	number = {13},
	year = {2002},
	pages = {755-765},
	abstract = {Identifying code duplication in large multi-platform software systems is a challenging problem. This is due to a variety of reasons including the presence of high-level programming languages and structures interleaved with hardware-dependent low-level resources and assembler code, the use of GUI-based configuration scripts generating commands to compile the system, and the extremely high number of possible different configurations. This paper studies the extent and the evolution of code duplications in the Linux kernel. Linux is a large, multi-platform software system; it is based on the Open Source concept, and so there are no obstacles in discussing its implementation. In addition, it is decidedly too large to be examined manually: the current Linux kernel release (2.4.18) is about three million LOCs. Nineteen releases, from 2.4.0 to 2.4.18, were processed and analyzed, identifying code duplication among Linux subsystems by means of a metric-based approach. The obtained results support the hypothesis that the Linux system does not contain a relevant fraction of code duplication. Furthermore, code duplication tends to remain stable across releases, thus suggesting a fairly stable structure, evolving smoothly without any evidence of degradation. (C) 2002 Elsevier Science B.V. All rights reserved.},
	keywords = {cvs, kernel, lines of code, linux, loc, project success, source code},
	url = {web.soccerlab.polymtl.ca/~antoniol/publications/.../infsoft2002.pdf},
	attachments = {https://flosshub.org/sites/flosshub.org/files/infsoft2002.pdf},
	author = {Antoniol, G. and Villano, U. and Merlo, E. and Di Penta, M.}
}
@article {flosswp40,
	title = {Cave or Community? An Empirical Examination of 100 Mature Open Source Projects},
	journal = {First Monday},
	volume = {7},
	number = {6},
	year = {2002},
	note = {The author conducts an empirical study of the top 100 mature projects on SourceForge.net to develop an understanding of the F/OSS community. The author sought empirical evidence that would help us understand which is more common- the cave (i.e., lone producer) or the community in F/OSS development. Some key findings include: first, most F/OSS programs are developed by individuals, rather than communities. Second, most OSS programs do not generate a lot of discussion. Third, products with more developers tend to be viewed and downloaded more often. Fourth, the number of developers associated with a project is unrelated to the age of the project.},
	month = {06/2002},
	abstract = {Starting with Eric Raymond{\textquoteright}s groundbreaking work, "The Cathedral and the Bazaar", open-source software (OSS) has commonly been regarded as work produced by a community of developers. Yet, given the nature of software programs, one also hears of developers with no lives that work very hard to achieve great product results. In this paper, I sought empirical evidence that would help us understand which is more common - the cave (i.e., lone producer) or the community. Based on a study of the top 100 mature products on Sourceforge, I find a few surprising things. First, most OSS programs are developed by individuals, rather than communities. The median number of developers in the 100 projects I looked at was 4 and the mode was 1 - numbers much lower than previous numbers reported for highly successful projects! Second, most OSS programs do not generate a lot of discussion. Third, products with more developers tend to be viewed and downloaded more often. Fourth, the number of developers associated with a project was positively correlated to the age of the project. Fifth, the larger the project, the smaller the percent of project administrators.},
	keywords = {age, contributors, developers, project success, registration, sourceforge},
	attachments = {https://flosshub.org/sites/flosshub.org/files/krishnamurthy.pdf},
	author = {Sandeep Krishnamurthy}
}
@conference {1153,
	title = {Characterizing the OSS process},
	booktitle = {Proceedings of the 2nd ICSE Workshop on Open Source},
	year = {2002},
	note = {"We have considered two well-known Open Source portals (FreshMeat [1] and SourceForge [2] )."
"Using pseudo-random sampling we have selected a sample of 400 projects (mostly from FreshMeat). Each project is described by several variables (programming language, type of license, size of source code, type of documentation available and others). By indirect means (analysis of the Changelog file, or CVS) it is also possible to compute the number of people working on the project, and the number of external contributors. From FreshMeat we get both a vitality index, that considers the number of releases per time period, and a popularity index, which is a first measure of the interest of users to the project (project URL hits, mixed with subscriptions to it)."},
	abstract = {The Open Source model of software development has gained the attention of both the business, the practitioners{\textquoteright} and the research communities. The Open Source process has been described by the seminal paper by Eric Raymond [4] and [5]. However, sound empirical studies are still very limited [3], [6].
Our goal is to investigate the OS process by empirical means, to analyze, characterize it, and possibly model it with quantitative models. It should be noted that the Open Source process provides open process and product data, and therefore is a rare opportunity for empirical research.
Our initial research focus is on the characterization of the process, starting from the evolution of OS projects. In traditional projects, a significant number of releases in a short time is usually considered an instability factor [7] and [8], while in the OSS community, it is an evidence of vitality, shows the commitment of the authors and the power of attraction of other programmers [9]. Is it possible to characterize the vitality of projects? And, can vitality be traced to some other characteristics of a project?},
	keywords = {bugs, change log, classification, cvs, downloads, freshmeat, metadata, patches, popularity, project success, release history, sourceforge, vitality},
	attachments = {https://flosshub.org/sites/flosshub.org/files/CapiluppiLagoMorisio.pdf},
	author = {Capiluppi, Andrea and Patricia Lago and Maurizio Morisio}
}
@article {Stamelos02codequality,
	title = {Code quality analysis in open source software development},
	journal = {Information Systems Journal},
	volume = {12},
	year = {2002},
	note = {"For our case study, we have used Logiscope{\quotesinglbase} (Telelogic, 2000), a comprehensive set of tools able to perform, automatically, code measurement and comparison with user-defined programming standards"
"Using Logiscope, we examined a sample of 100 C programs found in the SUSE Linux 6.0 release."
metrics collected:
number of statements
cyclomatic complexity
maximum levels
number of paths
unconditional jumps
comment frequency
vocabulary frequency
program length
average size
number of inputs/outputs},
	pages = {43{\textendash}60},
	abstract = {Proponents of open source style software development claim that better software is produced using this model compared with the traditional closed model. However, there is little empirical evidence in support of these claims. In this paper, we present the results of a pilot case study aiming: (a) to understand the implications of structural quality; and (b) to figure out the benefits of structural quality analysis of the code delivered by open source style development. To this end, we have measured quality characteristics of 100 applications written for Linux, using a software measurement tool, and compared the results with the industrial standard that is proposed by the tool. Another target of this case study was to investigate the issue of modularity in open source as this characteristic is being considered crucial by the proponents of open source for this type of software development. We have empirically assessed the relationship between the size of the application components and the delivered quality measured through user satisfaction. We have determined that, up to a certain extent, the average component size of an application is negatively related to the user satisfaction for this application.},
	keywords = {C, Code quality characteristics, functions, linux, metrics, open source development, software measurement, structural code analysis, Suse, user satisfaction},
	author = {Ioannis Stamelos and Lefteris Angelis and Apostolos Oikonomou and Georgios L. Bleris}
}
@proceedings {104,
	title = {Economic incentives for participating in open source software projects},
	year = {2002},
	note = {"The data for this research come from two primary sources: Apache project archives and a targeted survey of Apache participants. Archival data are open source project artifacts such as e-mail and source code archives, source code version control meta-data, and developer Web sites"
independent variables: patch, committer, work experience, programming experience, education, job switch, firm size, firm public, industry},
	pages = {365{\textendash}372},
	abstract = {Using the Internet as a basis for communication, collaboration, and storage of artifacts, the open source community is producing software of a quality that was previously thought to be achievable only by professional engineers following strict software development paradigms. This accomplishment is even more astounding as developers contribute to the source code without any remuneration. Open source leaders as well as academics have proposed theories about the motivation of open source developers that are rooted in diverse fields such as social psychology and anthropology. However, Lerner and Tirole (2000) argue that developer participation in open source projects may, in part, be explained by existing economic theory regarding career concerns. This research seeks to confirm or disconfirm the existence of economic returns to participation in open source development. Our findings suggest that greater open source participation per se, as measured in contributions made, is not associated with wage increases. However, a higher status in a merit-based ranking within the Apache Project is associated with significantly higher wages. This suggests that employers do not reward the gain in experience through open source participation as an increase in human capital. The results are also consistent with the notion that a high rank within the Apache Software Foundation is a credible signal of the productive capacity of a programmer.},
	keywords = {apache, contributions, email, email archives, mailing list, organizational sponsorship, participation, patch, scm, source code, Survey, version control},
	attachments = {https://flosshub.org/sites/flosshub.org/files/42.pdf},
	author = {Il-Horn Hann and Jeff Roberts and Sandra Slaughter and Roy Fielding}
}
@article {1251,
	title = {The Economics of Open Source Software: A Survey of the Early Literature},
	journal = {Review of Network Economics},
	volume = {1},
	number = {1},
	year = {2002},
	month = {03/2002},
	abstract = {This paper reviews the recent literature on the economics of open source software. Two different sets of issues are addressed. The first looks at the incentives of programmers to participate in open source projects. The second considers the business models used by profit-making firms in the open source industry, and the effects on existing closed source firms. Some possible future research directions are also given.},
	keywords = {business, commercial software, incentives, MOTIVATION},
	attachments = {https://flosshub.org/sites/flosshub.org/files/schiff.pdf},
	author = {Schiff, A.}
}
@article {1117,
	title = {Effort, co-operation and co-ordination in an open source software project: GNOME},
	journal = {Information Systems Journal},
	volume = {12},
	year = {2002},
	note = {"Also retrieved by a Perl script were the postings to the relevant discussion lists including the sender, the subject, time and complete text. For analysis of the posting behaviour of the programmers, the short name that each programmer uses for checkins had to be matched to the full name or email address used for postings. For 175 persons, this has been possible using several regular expressions with human check-up."},
	month = {01/2002},
	pages = {27 - 42},
	abstract = {This paper presents results from research into open source projects from a software engineering perspective. The research methodology employed relies on public data retrieved from the CVS repository of the GNOME project and relevant discussion groups. This methodology is described, and results concerning the special characteristics of open source software development are given. These data are used for a first approach to estimating the total effort to be expended.},
	keywords = {cvs, discussion, effort estimation, gnome},
	issn = {1365-2575},
	doi = {10.1046/j.1365-2575.2002.00110.x},
	author = {Koch, Stefan and Schneider, Georg}
}
@conference {1156,
	title = {The evolution of the GNOME Project},
	booktitle = {Proceedings of the 2nd ICSE Workshop on Open Source},
	year = {2002},
	abstract = {The GNOME Project is an attempt to create a GUI desktop for Unix systems. Originally started by a handful of volunteers in 1996, GNOME has become the desktop of choice for Solaris, HP-UX, and Red Hat Linux, and it is currently developed by a team of approximately five hundred people around the world. The importance of GNOME to the Unix world has attracted the attention of several software companies who are actively participating in its development. At the same time, some of its volunteer developers have created enterprises who expect to sell services and products around GNOME. This extended abstract describes, first, the development model of GNOME, then the influence that private companies had had on the project: on one hand they are contributing a large amount of resources to the project, accelerating its development, and increasing its reliability and documentation; and on the other hand, the GNOME Foundation has been created to maintain the goal of the project to provide a free (as in freedom) software desktop for Unix, and avoid that the commercial interests of these partners could jeopardize the interests of the community.},
	keywords = {commercial software, gnome, organizational sponsorship},
	attachments = {https://flosshub.org/sites/flosshub.org/files/German.pdf},
	author = {Daniel M. German}
}
@conference {Nakakoji:2002:EPO:512035.512055,
	title = {Evolution patterns of open-source software systems and communities},
	booktitle = {Proceedings of the International Workshop on Principles of Software Evolution},
	series = {IWPSE {\textquoteright}02},
	year = {2002},
	pages = {76{\textendash}85},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {Open-Source Software (OSS) development is regarded as a successful model of encouraging "natural product evolution". To understand how this "natural product evolution" happens, we have conducted a case study of four typical OSS projects. Unlike most previous studies on software evolution that focus on the evolution of the system per se, our study takes a broader perspective: It examines not only the evolution of OSS systems, but also the evolution of the associated OSS communities, as well as the relationship between the two types of evolution.Through the case study, we have found that while collaborative development within a community is the essential characteristic of OSS, different collaboration models exist, and that the difference in collaboration model results in different evolution patterns of OSS systems and communities. To treat such differences systematically, we propose to classify OSS into three types: Exploration-Oriented, Utility-Oriented, and Service-Oriented. Such a classification can provide guidance on the creation and maintenance of sustainable OSS development and communities.},
	keywords = {case study, open-source software (OSS), open-source software community, software evolution},
	isbn = {1-58113-545-9},
	doi = {10.1145/512035.512055},
	url = {http://doi.acm.org/10.1145/512035.512055},
	author = {Nakakoji, Kumiyo and Yamamoto, Yasuhiro and Nishinaka, Yoshiyuki and Kishida, Kouichi and Ye, Yunwen}
}
@conference {1163,
	title = {On the Nonmaintainability of Open-Source Software},
	booktitle = {Proceedings of the 2nd ICSE Workshop on Open Source},
	year = {2002},
	note = {"We downloaded 365 versions of Linux. For each version in turn, we examined the 17 kernel modules and counted the number of lines of code in each module. Then we counted the number of instances of common (global) coupling between each of the kernel modules and all the other modules in that version of Linux. We obtained two primary results."},
	keywords = {Common coupling, coupling, lines of code, linux, linux kernel, loc, metrics},
	attachments = {https://flosshub.org/sites/flosshub.org/files/SchachOffutt.pdf},
	author = {Schach, Stephen R. and Offutt, Jeff}
}
@article {flosswp59,
	title = {Open Source Software Projects as Virtual Organizations: Competency Rallying for Software Development},
	journal = {IEE Proceedings Software},
	volume = {149},
	number = {1},
	year = {2002},
	pages = {3{\textendash}17},
	abstract = {The contribution of this paper is the identification and testing of factors important for the success of Open Source Software (OSS) projects. We present an analysis of OSS communities as virtual organizations and apply Katzy and Crowston{\textquoteright}s (2000) competency rallying (CR) theory to the case of OSS development projects. CR theory suggests that project participants must develop necessary competencies, identify and understand market opportunities, marshal competencies to meet the opportunity and manage a short-term cooperative process. Using data collected from 7477 OSS projects hosted by the SourceForge system (http://sourceforge.net/), we formulate and test a set of specific hypotheses derived from CR theory.},
	keywords = {competencies, competency rallying, coordination, project success, sourceforge, virtual organizations},
	attachments = {https://flosshub.org/sites/flosshub.org/files/crowston.pdf},
	author = {Kevin Crowston and Barbara Scozzi}
}
@conference {Dinkelacker:2002:POS:581339.581363,
	title = {Progressive open source},
	booktitle = {Proceedings of the 24th International Conference on Software Engineering},
	series = {ICSE {\textquoteright}02},
	year = {2002},
	pages = {177{\textendash}184},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {The success of several Open Source{\texttrademark} software systems, e.g., Apache, Bind, Emacs, and Linux, has recently sparked interest in studying and emulating the software engineering principles underlying this innovative development and use model. Certain aspects of the Open Source development method, e.g., community building, open discussions for requirements and features, and evolvable and modular designs are having fundamental and far reaching consequences on general software engineering practices.To leverage such Open Source methods and tools, we have defined an innovative software engineering paradigm for large corporations: Progressive Open Source (POS). POS leverages the power of Open Source methods and tools for large corporations in a progressive manner: starting from completely within the corporation, to include partner businesses, and eventually complete Open Source. In this paper we present the design goals and principles for POS. We illustrate POS with two programs in HP: Corporate Source and the Collaborative Development Program (CDP). We present early results from both these programs suggesting the power and necessity of POS for all modern large corporations.},
	keywords = {companies},
	isbn = {1-58113-472-X},
	doi = {10.1145/581339.581363},
	url = {http://doi.acm.org/10.1145/581339.581363},
	author = {Dinkelacker, Jamie and Garg, Pankaj K. and Miller, Rob and Nelson, Dean}
}
@article {Hissam,
	title = {Trust and vulnerability in open source software},
	journal = {Software, {IEE} Proceedings -},
	volume = {149},
	number = {1},
	year = {2002},
	month = {02/2002},
	pages = {47{\textendash}51},
	chapter = {47},
	abstract = {Software plays an ever increasing role in the critical infrastructures that run our cities, manage our economies, and defend our nations. In 1999, the Presidents Information Technology Advisory Committee (PITAC) reported to the United States President the need for software components that are reliable, tested, modelled and secure supporting the development of predictably reliable and secure systems that underscore our critical infrastructures. Open source software (OSS) constitutes a viable source for software components. Some believe that OSS is more reliable and more secure than closed source software (CSS)-due to a phenomenon dubbed {\textquoteright}many eyeballs{\textquoteright}-but is this truly the case? Or does OSS give the cyber criminal an edge that he would likewise not have? We explore OSS from the perspective of the cyber criminal and discuss what the community of software developers and users alike can do to increase their trust in both open source software and closed source software},
	keywords = {closed source software, community of software developers, critical infrastructures, cyber criminal, open source software, PITAC, predictably reliable systems, predictably secure systems, software components, trust, users, vulnerability},
	issn = {1462-5970},
	doi = {10.1049/ip-sen:20020208},
	author = {Hissam, S. A. and Plakosh, D. and Weinstock, C.}
}
@article {121,
	title = {Two case studies of open source software development: Apache and Mozilla},
	journal = {ACM Transactions on Software Engineering and Methodology},
	volume = {11},
	number = {3},
	year = {2002},
	note = {apache data sources:
email, cvs, bug database 
regarding email: "We wrote Perl scripts to extract date, sender identity, message subject, and the message body that was further processed to obtain details on code changes and problem reports (see below). Manual inspection was used to resolve such things as multiple email addresses in cases where all automated techniques failed."
(but the rest of the paper does not address this data source at all)

mozilla data sources
bugzilla, cvs

},
	pages = {309-346},
	abstract = {According to its proponents, open source style software development has the capacity to compete successfully, and perhaps in many cases displace, traditional commercial development methods. In order to begin investigating such claims, we examine data from two major open source projects, the Apache web server and the Mozilla browser. By using email archives of source code change history and problem reports we quantify aspects of developer participation, core team size, code ownership, productivity, defect density, and problem resolution intervals for these OSS projects. We develop several hypotheses by comparing the Apache project with several commercial projects. We then test and refine several of these hypotheses, based on an analysis of Mozilla data. We conclude with thoughts about the prospects for high- performance commercial/ open source process hybrids.},
	keywords = {apache, bug fixing, bug reports, bugzilla, change history, core, defect density, email, email archives, mailing list, mozilla, ownership, participation, productivity, scm, source code},
	attachments = {https://flosshub.org/sites/flosshub.org/files/mockusFieldingHerbsleb2002.pdf},
	author = {Audris Mockus and Roy Fielding and Herbsleb, J. D.}
}
@conference {1154,
	title = {Version Control: A Case Study in the Challenges and Opportunities for Open Source Software Development},
	booktitle = {Proceedings of the 2nd ICSE Workshop on Open Source},
	year = {2002},
	abstract = {The growth of the worldwide open source development effort, driven in part by the recent entrance of large corporations into the open source arena, offers new opportunities to improve the software engineering tools available for that effort. Indeed, the increasing difficulty of managing large open source projects, as well as that of integrating related efforts into new programming environments, represents a challenge that must be met if the rapid growth of open source software is to continue. This position paper addresses these issues in the context of software version control.},
	keywords = {cvs, kernel, linux, linux kernel, version control},
	attachments = {https://flosshub.org/sites/flosshub.org/files/ChuCarrollShieldsWright.pdf},
	author = {Chu-Carroll, M.C. and Sheilds, D. and Wright, J.}
}
@conference {1157,
	title = {Why Do Developers Contribute to Open Source Projects? First Evidence of Economic Incentives},
	booktitle = {Proceedings of the 2nd ICSE Workshop on Open Source},
	year = {2002},
	note = {"The data for this research come from two primary sources: Apache project archives and a targeted survey of Apache participants. Archival data are open source project artifacts such as email and source code archives, source code version control meta-data and developer web sites."},
	abstract = {The availability of commercial quality, free software products such as the Apache HTTP (web) server or the Linux operating system has focused significant attention on the open source development process by which these products were created. One of the more perplexing aspects of open source software projects is why developers freely devote their time and energy to these projects. While many open source participants cite idealistic motives for participation, Lerner and Tirole (2000) argue that developer participation in open source projects may, in part, be explained by existing economic theory regarding career concerns. This research seeks to confirm or disconfirm the existence of economic returns to participation in open source development. Preliminary results of our empirical investigation suggest that greater open source participation per se, as measured in contributions made, does not lead to wage increases. However, a higher status in a merit-based ranking within the Apache Project does lead to significantly higher wages. This suggests that employers do not reward the gain in experience through open source participation as an increase in human capital. The results are also consistent with the notion that a high rank within the Apache Software Foundation is a credible signal of the productive capacity of a programmer.},
	keywords = {apache, contributions, cvs, developers, ECONOMICS, email, email archives, financial, Human capital, mailing list, MOTIVATION, participation, source code, version control},
	attachments = {https://flosshub.org/sites/flosshub.org/files/HannRobertsSlaughterFielding.pdf},
	author = {Il-Horn Hann and Jeff Roberts and Sandra Slaughter and Roy Fielding}
}
@conference {1159,
	title = {Why Not Improve Coordination in Distributed Software Development by Stealing Good Ideas from Open Source?},
	booktitle = {Proceedings of the 2nd ICSE Workshop on Open Source},
	year = {2002},
	keywords = {apache, communication, coordination, distributed},
	attachments = {https://flosshub.org/sites/flosshub.org/files/MockusHerbsleb.pdf},
	author = {Audris Mockus and Herbsleb, James}
}
@article {54,
	title = {Code, Culture and Cash: The Fading Altruism of Open Source Development},
	journal = {First Monday},
	volume = {6},
	number = {12},
	year = {2001},
	note = {"I collected information on the country of residence for key contributors to the two projects. In the case of Linux, I relied on information located in the CREDITS file of all major kernel releases (from version 1.0 to version 2.4.9) [22]. For Gnome, I gathered developer-contact information from the project{\textquoteright}s web-site. Where information on the home-country of developers was not explicitly available, I performed private research to ascertain said information, or - in the last-case scenario - trusted information in the provided e-mail address of developers to infer home-country from domain ownership [23]. In the case of Linux, to avoid bias that might be introduced over time as developers migrated internationally, developers are continually counted as residents of the countries they were associated with when their names first entered the CREDITS file"},
	abstract = {The nexus of open source development appears to have shifted to Europe over the last ten years. This paper explains why this trend undermines cultural arguments about "hacker ethics" and "post-scarcity" gift economies. It suggests that classical economic theory offers a more succinct explanation for the peculiar international distribution of open source development: hacking rises and falls inversely to its opportunity cost. This finding throws doubt on the Schumpeterian assumption that the efficiency of industrial systems can be measured without reference to the social institutions that bind them.},
	keywords = {credits, email address, european, geography, gnome, linux},
	url = {http://131.193.153.231/www/issues/issue6_12/lancashire/index.html},
	attachments = {https://flosshub.org/sites/flosshub.org/files/Lancashire.pdf},
	author = {David Lancashire}
}
@conference {1136,
	title = {Configuration Management for Open Source Software},
	booktitle = {1st Workshop on Open Source Software Engineering at ICSE 2001},
	year = {2001},
	month = {05/2001},
	abstract = {Open Source Software (OSS) projects have a seemingly anarchistic way of organising projects and a set-up (many, distributed developers) that is usually considered difficult to handle within the field of configuration management. Still they manage to produce software that is of at least as high a quality as that produced by Conventional Software Development (CSD) projects.
We have investigated more closely what they actually do, and why they are so successful. The goal of the study was to describe their underlying configuration management process, thereby making it explicit, so it can be followed in case others (like commercial companies) want to start an OSS project or a project having similar characteristics. We also analysed to what extent their success is due to a good process, good tools or simply to outstanding people participating in OSS projects. Based on this, lessons could be learned from OSS and possible transferred to conventional ways of developing software. We interviewed key people from three OSS projects (KDE, Mozilla and Linux) to obtain data for our study.},
	keywords = {configuration management, interviews, project success},
	attachments = {https://flosshub.org/sites/flosshub.org/files/asklundbendix.pdf},
	author = {Asklund, U. and Bendix, L.}
}
@conference {1141,
	title = {Corporate Source: Applying Open Source Concepts to a Corporate Environment},
	booktitle = {1st Workshop on Open Source Software Engineering at ICSE 2001},
	year = {2001},
	keywords = {commercial software, hewlett packard, hp, organizational sponsorship},
	attachments = {https://flosshub.org/sites/flosshub.org/files/dinkelackergarg.pdf},
	author = {Dinkelacker, J. and Garg, P.K.}
}
@conference {1138,
	title = {Creating a Free, Dependable Software Engineering Environment for Building Java Applications},
	booktitle = {1st Workshop on Open Source Software Engineering at ICSE 2001},
	year = {2001},
	abstract = {As open source software engineering becomes more prevalent, employing sound software engineering practices and the tools used to implement these practices becomes more important. This paper examines the current status of free software engineering tools. For each set of tools, we determined the important attributes that would best assist a developer in each stage of the waterfall model. We rated each tool based on predetermined attributes. We used the creation of a graphical user interface based email client in Java to assist in evaluating each tool. Our findings show that there is still a need for free tools to extract UML diagrams, test graphical user interfaces, make configuring Emacs easier, and profile Java applications. In other areas there are free tools that provide satisfactory functionality such as Concurrent Versions System (CVS), GVim, JUnit, JRefactory, GNU Make, Jakarta Ant, Javadoc, and Doc++.},
	keywords = {applications, cvs, Doc++, GNU Make, GVim, Jakarta Ant, java, Javadoc, jrefactory, junit, tools},
	attachments = {https://flosshub.org/sites/flosshub.org/files/bittman.pdf},
	author = {Bittman, M. and Roos, R. and Kapfhammer, G.M.}
}
@proceedings {140,
	title = {An exploratory study of ideology and trust in open source development groups},
	year = {2001},
	note = {"To do this, we scanned information in the public domain to develop a preliminary understanding of the context. We then identified 48 OS projects using www.sourceforge.net, an on-line open source meeting place that provides information on open source efforts and hosts code repositories. Projects were selected to represent a variety of types of software, licenses, and group sizes. We contacted administrators or project leaders and asked them to complete open-ended questionnaires regarding their experience and views on open source development."},
	abstract = {Open source (OS) software development has been the subject of heightened interest among organizational scholars because of the novel social coordination practices that signal a departure from traditional proprietary software development. We propose that trust among group members in open source development groups (OSDGs) plays a key role in facilitating their success. Trust is important in this context because of the risk of opportunistic behavior by other members who volunteers may not have met and may never expect to meet, as well as a lack of explicit market contracts or common organizational affiliation. The open source community is differentiated by a coherent ideology that emphasizes a distinct set of interrelated norms, beliefs, and values. These serve to create incentives for open source practices that eschew conventional transactional norms in favor of a gift culture and a focus on reputations. In this study, we primarily examine the role of the shared ideology in enabling the development of affective and cognitive trust in OSDGs. We further examine how this trust leads to desired outcomes - group efficacy and effectiveness. The study is based on exploratory interviews, examination of archival records and a preliminary survey to understand the specific conditions of open source efforts on which this work-in-progress report is based. This is being followed-up by empirical testing of our research model through a survey of a broad variety of OSDGs. This study would contribute to a clarification of the role of trust in enabling software groups to work effectively and help to understand the bases of trust in ideology-permeated groups.},
	keywords = {contributors, groups, ideology, license analysis, licenses, metadata, open source, sourceforge, Survey, team, team size, teams, trust, types},
	doi = {10.1.1.104.638},
	url = {http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.104.638\&rep=rep1\&type=pdf},
	attachments = {https://flosshub.org/sites/flosshub.org/files/stewartGosain2001.pdf},
	author = {Katherine Stewart and Gosain, S.}
}
@conference {Godfrey:2001:GES:602461.602482,
	title = {Growth, evolution, and structural change in open source software},
	booktitle = {Proceedings of the 4th International Workshop on Principles of Software Evolution (IWPSE 2001)},
	series = {IWPSE {\textquoteright}01},
	year = {2001},
	note = {"We measured [linux] system size in uncommented LOC"
"We also examined the growth of several other open source systems, including the VIM text editor, Eric Raymond{\textquoteright}s fetchmail utility, and the GCC compiler suite. "},
	pages = {103{\textendash}106},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {Our recent work has addressed how and why software systems evolve over time, with a particular emphasis on software architecture and open source software systems [2, 3, 6]. In this position paper, we present a short summary of two recent projects. First, we have performed a case study on the evolution of the Linux kernel [3], as well as some other open source software (OSS) systems. We have found that several OSS systems appear not to obey some of "Lehman{\textquoteright}s laws" of software evolution [5, 7], and that Linux in particular is continuing to grow at a geometric rate. Currently, we are working on a detailed study of the evolution of one of the subsystems of the Linux kernel: the SCSI drivers subsystem. We have found that cloning, which is usually considered to be an indicator of lazy development and poor process, is quite common and is even considered to be a useful practice. Second, we are developing a tool called Beagle to aid software maintainers in understanding how large systems have changed over time. Beagle integrates data from various static analysis and metrics tools and provides a query engine as well as navigable visualizations. Of particular note, Beagle aims to provide help in modelling long term evolution of systems that have undergone architectural and structural change.},
	keywords = {agile methods, beagle, cloning, evolution, fetchmail, gcc, growth, kernel, lehman{\textquoteright}s laws, lines of code, linux, linux kernel, loc, open source software, software architecture, software evolution, source code, structural change, supporting environments, vim},
	isbn = {1-58113-508-4},
	doi = {http://doi.acm.org/10.1145/602461.602482},
	url = {http://doi.acm.org/10.1145/602461.602482},
	attachments = {https://flosshub.org/sites/flosshub.org/files/tu2001.pdf},
	author = {Michael Godfrey and Tu, Qiang}
}
@conference {1151,
	title = {Open Source Development: A suitable Method to introduce a standardized communication protocol?},
	booktitle = {1st Workshop on Open Source Software Engineering at ICSE 2001},
	year = {2001},
	abstract = {Open Source developments like telnet and Apache are very important for an extensive and compatible use of the TCP/IP and the HTTP protocol. Both contain features which rely on a compatible implementation of complex interactions between computers of different platform types. This can be successfully achieved with the help of Open Source.	Reconciliation	of	different interpretations of the standard, clarifications and extensions can be realised by discussion systems	and	some	generally	accepted conciliators of Open Source projects. As long as companies have a commercial interest in selling solutions based on the protocol, it makes economic sense for them to jointly support its common implementation. This paper examines the possibility to use an Open Source reference implementation of the agricultural communication protocols DIN 9684 [1] [2] and ISO 11783 to establish a capable and compatible implementation in agricultural mobile process control and data collection.},
	keywords = {communication protocol, DIN 9684, ISO 11783, open source},
	attachments = {https://flosshub.org/sites/flosshub.org/files/spangler.pdf},
	author = {Spangler, Achim}
}
@conference {1139,
	title = {Open Source Development: An Arthurian Legend},
	booktitle = {1st Workshop on Open Source Software Engineering at ICSE 2001},
	year = {2001},
	abstract = {OSSD (Open Source Software Development) achieves remarkable success in delivering complex software systems {\textendash} systems which are incredibly reliable and robust {\textendash} in a short amount of time and without even paying anyone! Naturally, in the face of this success, organizations are interested in seeing if the mechanisms behind OSSD success can be migrated into their own practices, hopefully improving their systems and their productivity.
In this paper, we look (lighthearted at first) at the motivations behind those involved in OSSD and describe the problems that need to be overcome if OSSD-type practices can be migrated into traditional organizations.},
	keywords = {commercial software, developers, MOTIVATION},
	attachments = {https://flosshub.org/sites/flosshub.org/files/cook.pdf},
	author = {Cook, J.}
}
@conference {1143,
	title = {Open Source Software: The Other Commercial Software},
	booktitle = {1st Workshop on Open Source Software Engineering at ICSE 2001},
	year = {2001},
	abstract = {Open source software is a source of components from which systems can be built. Components can also be acquired in the marketplace. There are a myriad of issues that affect software that incorporates commercial components. These issues (and others) also affect open source software. In this paper we examine issues that an organization using open source software is likely to face in light of lessons learned from the world of commercial components},
	keywords = {commercial off-the-shelf software, commercial software, COTS software, open source software},
	attachments = {https://flosshub.org/sites/flosshub.org/files/hissamweinstock.pdf},
	author = {Hissam, S. and Weinstock, C.}
}
@conference {1145,
	title = {Reputation Layers for Open-Source Development},
	booktitle = {1st Workshop on Open Source Software Engineering at ICSE 2001},
	year = {2001},
	keywords = {currency, developers, MOTIVATION, reputation},
	attachments = {https://flosshub.org/sites/flosshub.org/files/masum.pdf},
	author = {Hasan Masum}
}
@conference {1149,
	title = {Software Development Practices in Open Software Development Communities: A Comparative Case Study},
	booktitle = {1st Workshop on Open Source Software Engineering at ICSE 2001},
	year = {2001},
	abstract = {This study presents an initial set of findings from an empirical study of social processes, technical system configurations, organizational contexts, and interrelationships that give rise to open software. "Open software", or more narrowly, open source software, represents an approach for communities of like-minded participants to develop software system representations that are intended to be shared freely, rather than offered as closed commercial products. While there is a growing popular literature attesting to open software [DiBona, Ockman, Stone 1999, Fogel 1999], there are very few systematic studies [e.g., Feller and Fitzgerald 2000, Mockus, Fielding, Herbsleb 2000] that informs how these communities produce software. Similarly, little is known about how people in these communities coordinate software development across different settings, or about what software processes, work practices, and organizational contexts are necessary to their success. To the extent that academic research communities and commercial enterprises seek the supposed efficacy of open software [Smarr and Graham 2000], they will need grounded models of the processes and practices of open software development to allow effective investment of their resources. This study investigates four communities engaged in open software development. Case study methods are used to compare practices across communities.},
	keywords = {apache, argouml, astronomy, chandra, games, infrastructure, internet news, mozilla, systems design},
	attachments = {https://flosshub.org/sites/flosshub.org/files/scacchi.pdf},
	author = {Walt Scacchi}
}
@article {98,
	title = {Striking a balance between trust anti control in a virtual organization: a content analysis of open source software case studies},
	journal = {Information Systems Journal},
	volume = {11},
	number = {4},
	year = {2001},
	note = {"I employ secondary analysis of published case studies of OSS projects. I used several search methods to identify such case studies about OSS pro- jects. First, I searched the electronic archives of both ACM and IEEE, using terms such as {\textquoteleft}open source.{\textquoteright} "
"Secondly, I searched on Bell \& Howell/Proquest{\textquoteright}s ABI/Inform, a database of acade- mic and trade publications on business and management (including technology management). Thirdly, I reviewed the {\textquoteleft}position papers{\textquoteright} of the various authors who attended the 1st Work- shop on Open-Source Software Engineering (Feller et al., 2001) for relevant case studies. Fourthly, I searched on Harvard Publishing{\textquoteright}s websites, which contain case studies published"
"Finally, as I located case studies or other publi- cations about OSS projects, I followed references from them to identify other case studies. Although I found literally hundreds of publications about OSS development, there was a much smaller number of case studies"},
	pages = {277-304},
	abstract = {Many organization theorists have predicted the emergence of the networked or virtual firm as a model for the design of future organizations. Researchers have also emphasized the importance of trust as a necessary condition for ensuring the success of virtual organizations. This paper examines the open source software (OSS) {\textquoteright}movement{\textquoteright} as an example of a virtual organization and proposes a model that runs contrary to the belief that trust is critical for virtual organizations. Instead, I argue that various control mechanisms can ensure the effective performance of autonomous agents who participate in virtual organizations. Borrowing from the theory of the {\textquoteright}McDonaldization{\textquoteright} of society, I argue that, given a set of practices to ensure the control, efficiency, predictability and calculability of processes and outcomes in virtual organizations, effective performance may occur in the absence of trust. As support for my argument, I employ content analysis to examine a set of published case studies of OSS projects. My results show that, although that trust is rarely mentioned, ensuring control is an important criterion for effective performance within OSS projects. The case studies feature few references to other dimensions of {\textquoteright}McDonaldization{\textquoteright} (efficiency, predictability and calculability), however, and I conclude that the OSS movement relies on many other forms of social control and self-control, which are often unacknowledged in OSS projects. Through these implicit forms of control, OSS projects are able to secure the cooperation of the autonomous agents that participate in project teams. I conclude by extrapolating from these case studies to other virtual organizations.},
	keywords = {apache, case studies, Control, fetchmail, jun, linux, linux kernel, McDonaldization, mozilla, networked organization, perl, rationalization, trust, virtual organization},
	author = {Gallivan, M. J.}
}
@article {flosswp26,
	title = {A Case Study of Open Source Software Development: The Apache Server},
	journal = {Proceedings of the International Conference on Software Engineering (ICSE 2000)},
	year = {2000},
	note = {We used the following archival sources of data:
Developer email list (EMAIL).
Concurrent Version Control archive (CVS).
Problem reporting database (BUGDB).},
	month = {June},
	abstract = {According to its proponents, open source style software development has the capacity to compete successfully, and perhaps in many cases displace, traditional commercial development methods. We examine the development process of a major open source application, the Apache web server. By using email archives of source code change history and problem reports we quantify aspects of developer participation, core team size, code ownership, productivity, defect density, and problem resolution interval for this OSS project. This analysis reveals a unique process, which performs well on important measures.},
	keywords = {apache, bug fix revisions, bugs, core, cvs, defect density, developers, email archives, participation, productivity, revision control, revision history, roles, scm, source code, team size},
	attachments = {https://flosshub.org/sites/flosshub.org/files/mockusapache.pdf},
	author = {Audris Mockus and Roy Fielding and Herbsleb, James}
}
@conference {Yamauchi:2000:CLM:358916.359004,
	title = {Collaboration with Lean Media: how open-source software succeeds},
	booktitle = {Proceedings of the 2000 ACM conference on Computer supported cooperative work (CSCW)},
	series = {CSCW {\textquoteright}00},
	year = {2000},
	pages = {329{\textendash}338},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {Open-source software, usually created by volunteer programmers dispersed worldwide, now competes with that developed by software firms. This achievement is particularly impressive as open-source programmers rarely meet. They rely heavily on electronic media, which preclude the benefits of face-to-face contact that programmers enjoy within firms. In this paper, we describe findings that address this paradox based on observation, interviews and quantitative analyses of two open-source projects. The findings suggest that spontaneous work coordinated afterward is effective, rational organizational culture helps achieve agreement among members and communications media moderately support spontaneous work. These findings can imply a new model of dispersed collaboration.},
	keywords = {cooperative work, cvs, distributed work, electronic media, INNOVATION, open-source, software engineering},
	isbn = {1-58113-222-0},
	doi = {10.1145/358916.359004},
	url = {http://doi.acm.org/10.1145/358916.359004},
	author = {Yamauchi, Yutaka and Yokozawa, Makoto and Shinohara, Takeshi and Ishida, Toru}
}
