@proceedings {1910,
	title = {Charting the market disruptive nature of Open Source: Experiences from Sony Mobile },
	year = {2017},
	month = {05/2017},
	pages = {175-176},
	abstract = {Open Source Software (OSS) has substantial impact
on how software-intensive firms develop products and deliver
value to the customers. These companies need both strategic
and operational support on how to adapt OSS as a part of their
products and how to adjust processes and organizations to
increase the benefits from OSS participation. This work
presents the key insights from the journey that Sony Mobile
has made from a company developing proprietary software to
a respected member of OSS communities. We framed the
experiences into an Open Source Maturity Model that includes
two scenarios: engineering-driven and business-driven open
source. We outline the most important decisions, roles,
processes and implications. },
	keywords = {ecosystem, poster, software business},
	author = {Mols, CE and Wnuk, K}
}
@proceedings {1915,
	title = {Classifying code comments in Java open-source software systems},
	year = {2017},
	note = {"we conducted an in-depth analysis of the
comments in the source code files of six major OSS systems
in Java"},
	month = {05/2017},
	pages = {227-237},
	abstract = {Code comments are a key software component
containing information about the underlying implementation.
Several studies have shown that code comments enhance the
readability of the code. Nevertheless, not all the comments have
the same goal and target audience. In this paper, we investigate
how six diverse Java OSS projects use code comments, with the
aim of understanding their purpose. Through our analysis, we
produce a taxonomy of source code comments; subsequently, we
investigate how often each category occur by manually classifying
more than 2,000 code comments from the aforementioned
projects. In addition, we conduct an initial evaluation on how
to automatically classify code comments at line level into our
taxonomy using machine learning; initial results are promising
and suggest that an accurate classification is within reach.},
	keywords = {java, Survey},
	author = {Luca Pascarella and Bacchelli, Alberto}
}
@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 {1912,
	title = {Developer Turnover in Global, Industrial Open Source Projects: Insights from Applying Survival Analysis},
	year = {2017},
	note = {we study five industrial OSS projects of different
sizes (in terms of software size, contributors and number
of companies involved) and examine whether the duration
of developers staying in a project is related to following
four factors: (i) the time of first contribution, (ii) the rate of
maintaining own files, (iii) the main action type, and (iv) the
main job type

projects:
WikiMedia, OpenStack, GlusterFS from Red
Hat, Xen Project from the Linux Foundation and Apache
CloudStack},
	month = {05/2017},
	pages = {66-75},
	abstract = {Large open source software projects often have
a globally distributed development team. Studies have shown
developer turnover has a significant impact on the project success.
Frequent developer turnover may lead to loss of productivity due
to lacking relevant knowledge and spending extra time learning
how projects work. Thus, lots of attention has been paid to which
factors are related to developer retention; however, few of them
focus on the impact of activities of individual developers.
In this paper, we study five open source projects from
different organizations and examine whether developer turnover
is affected by when they start contributing and what types of
contributions they are making. Our study reveals that developers
have higher chances to survive in software projects when they
1) start contributing to the project earlier; 2) mainly modify
instead of creating files; 3) mainly code instead of dealing with
documentations. Our results also shed lights on the potential
approaches to improving developer retention.},
	keywords = {survival analysis},
	author = {Bin Lin and Gregorio Robles and Serebrenik, Alexander}
}
@proceedings {1907,
	title = {Do Software Developers Understand Open Source Licenses?},
	year = {2017},
	note = {Data: We report on the results of a survey that asked
developers about 42 different cases of the use of code under
different open source licenses. To make the survey tractable
for developers to answer, we focused on three popular open
source licenses (GNU GPL 3.0, GNU LGPL 3.0 and MPL
2.0)

Findings: The survey results indicate that most of the 375 respondents
to our survey struggle with understanding the interaction of
open source licenses in both simple and complex software
development cases},
	month = {05/2017},
	pages = {1-11},
	abstract = {{\textemdash}Software provided under open source licenses is
widely used, from forming high-profile stand-alone applications
(e.g., Mozilla Firefox) to being embedded in commercial offerings
(e.g., network routers). Despite the high frequency of use of open
source licenses, there has been little work about whether software
developers understand the open source licenses they use. To our
knowledge, only one survey has been conducted, which focused
on which licenses developers choose and when they encounter
problems with licensing open source software. To help fill the
gap of whether or not developers understand the open source
licenses they use, we conducted a survey that posed development
scenarios involving three popular open source licenses (GNU GPL
3.0, GNU LGPL 3.0 and MPL 2.0) both alone and in combination.
The 375 respondents to the survey, who were largely developers,
gave answers consistent with those of a legal expert{\textquoteright}s opinion in
62\% of 42 cases. Although developers clearly understood cases
involving one license, they struggled when multiple licenses were
involved. An analysis of the quantitative and qualitative results of
the study indicate a need for tool support to help guide developers
in understanding this critical information attached to software
components.},
	keywords = {license, Survey},
	doi = {10.1109/ICPC.2017.7},
	author = {Almeida, Daniel A. and Murphy, Gail C. and Wilson, Greg and Hoye, Mike}
}
@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}
}
@inbook {Kerzazi2017,
	title = {Knowledge Flows Within Open Source Software Projects: A Social Network Perspective},
	booktitle = {Advances in Ubiquitous Networking 2: Proceedings of the UNet{\textquoteright}16},
	year = {2017},
	pages = {247{\textendash}258},
	publisher = {Springer Singapore},
	organization = {Springer Singapore},
	address = {Singapore},
	abstract = {Developing software is knowledge-intensive activity, requiring extensive technical knowledge and awareness. The abstract part of development is the social interactions that drive knowledge flows between contributors, especially for Open Source Software (OSS). This study investigated knowledge sharing and propagation from social perspective using social network analysis (SNA). We mined and analyzed the issue and review histories of three OSS from GitHub. Particular attention has been paid to the socio-interactions through comments from contributors on reviews. We aim at explaining the propagation and density of knowledge flows within contributor networks. The results show that review requests flow from the core contributors toward peripheral contributors and comments on reviews are in a continuous loop from the core teams to the peripherals and back; and the core contributors leverage on their awareness and technical knowledge to increase their notoriety by playing the role of communication brokers supported by comments on work items.},
	keywords = {expertise, Knowledge flows, open source, SNA},
	isbn = {978-981-10-1627-1},
	doi = {10.1007/978-981-10-1627-1_19},
	url = {http://dx.doi.org/10.1007/978-981-10-1627-1_19},
	author = {Kerzazi, Noureddine and El Asri, Ikram},
	editor = {El-Azouzi, Rachid and Menasche, Daniel Sadoc and Sabir, Essa{\"\i}d and De Pellegrini, Francesco and Benjillali, Mustapha}
}
@proceedings {1904,
	title = {OSSpal: Finding and Evaluating Open Source Software},
	volume = {496},
	year = {2017},
	month = {05/2017},
	pages = {193-203},
	publisher = {Springer},
	abstract = {This paper describes the OSSpal project, which is aimed at helping companies, government agencies, and other organizations find high quality free and open source software (FOSS) that meets their needs. OSSpal is a successor to the Business Readiness Rating (BRR), combining quantitative and qualitative evaluation measures for software in various categories. Instead of a purely numeric calculated score OSSpal adds curation of high-quality FOSS projects and individual user reviews of these criteria. Unlike the BRR project, for which there was no automated support, OSSpal has an operational, publicly available website where users may search by project name or category, and enter ratings and reviews for projects.

},
	keywords = {Open source forges, software evaluation, software metrics, Software taxonomy},
	doi = {10.1007/978-3-319-57735-7_18},
	url = {https://link.springer.com/chapter/10.1007/978-3-319-57735-7_18},
	author = {Wasserman, A. and Guo, X. and McMillian, B. and Qian K. and Wei M.Y. and Xu, Q.}
}
@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 {1897,
	title = {Understanding the Effects of Practices on KDE Ecosystem Health},
	volume = {496},
	year = {2017},
	month = {05/2017},
	pages = {89-100},
	publisher = {Springer},
	abstract = {Open source software ecosystems have adjusted and evolved a set of practices over the years to support the delivery of sustainable software. However, few studies have investigated the impacts of such practices on the health of these ecosystems. In this paper, we present the results of an ethnographic-based study conducted during the Latin-American KDE users and contributors meeting (LaKademy 2015) with the goal of collecting practices used within the KDE ecosystem and understanding how they affect ecosystem health. The analysis was based on softgoal interdependency graphs adapted to represent practices and relate them to non-functional requirements and goals. Our results provide a preliminary insight to understand how KDE ecosystem community interacts, which working practices have been adopted and how they affect ecosystem health.

},
	keywords = {Ethnographic studies, Open source software ecosystems, Software ecosystem health, Software practices},
	doi = {10.1007/978-3-319-57735-7_10},
	url = {https://link.springer.com/chapter/10.1007/978-3-319-57735-7_10},
	author = {Simone da Silva Amorim and John D. McGregor and Eduardo Santana de Almeida and Christina von Flach Garcia Chavez}
}
@proceedings {1917,
	title = {Understanding the Impressions, Motivations, and Barriers of One Time Code Contributors to FLOSS Projects: A Survey},
	year = {2017},
	month = {05/2017},
	pages = {187-197},
	abstract = {Successful Free/Libre Open Source Software
(FLOSS) projects must attract and retain high-quality talent.
Researchers have invested considerable effort in the study of
core and peripheral FLOSS developers. To this point, one critical
subset of developers that have not been studied are One-Time
code Contributors (OTC) {\textendash} those that have had exactly one patch
accepted. To understand why OTCs have not contributed another
patch and provide guidance to FLOSS projects on retaining
OTCs, this study seeks to understand the impressions, motivations,
and barriers experienced by OTCs. We conducted an online
survey of OTCs from 23 popular FLOSS projects. Based on the
184 responses received, we observed that OTCs generally have
positive impressions of their FLOSS project and are driven by a
variety of motivations. Most OTCs primarily made contributions
to fix bugs that impeded their work and did not plan on becoming
long term contributors. Furthermore, OTCs encounter a number
of barriers that prevent them from continuing to contribute to the
project. Based on our findings, there are some concrete actions
FLOSS projects can take to increase the chances of converting
OTCs into long-term contributors.},
	keywords = {newcomers, One Time Contributors, Qualitative Research, Survey},
	author = {Amanda Lee and Carver, Jeffrey C. and Bosu, Amiangshu}
}
@proceedings {1918,
	title = {Using Gamification to Orient and Motivate Students to Contribute to OSS Projects},
	year = {2017},
	month = {05/2017},
	pages = {36-42},
	abstract = {Students can benefit from contributing to Open Source Software (OSS), since they can enrich their portfolio and learn with real world projects. However, sometimes students are demotivated to contribute due to entrance barriers. On the other hand, gamification is widely used to engage and motivate people to accomplish tasks and improve their performance. The goal of this work is to analyze the use of gamification to orient and motivate undergraduate students to overcome onboarding barriers and engage to OSS projects. To achieve this goal, we implemented four gaming elements (Quests, Points, Ranking, and Levels) in GitLab and assessed the environment by means of a study conducted with 17 students within a real OSS project (JabRed). At the end of the study, the students evaluated their experience through a questionnaire. We found that the Quest element helped to guide participants and keep them motivated and points helped by providing feedback on students{\textquoteright} performed tasks. We conclude that the gamified environment oriented the students in an attempt to make a contribution and that gamification can motivate and orient newcomers{\textquoteright} to engage to OSS projects. },
	keywords = {engagement, gamification, MOTIVATION, newcomers, students},
	author = {Guilherme C. Diniz and Marco A. Graciotto Silva and Marco Gerosa and Steinmacher, Igor}
}
@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}
}
@proceedings {1808,
	title = {How Do Free/Open Source Developers Pick Their Tools? A Delphi Study of the Debian Project},
	year = {2016},
	abstract = {Free and Open Source Software (FOSS) has come to play a critical role in the global software industry. Organizations are widely adopting FOSS and interacting with open source communities, and hence organizations have a considerable interest in seeing these communities flourishing. Very little research has focused on the tools used to develop that software. Given the absence of organizational policies and mandate that would occur in a traditional environment, an open question is how FOSS developers decide what tools to use. In this paper we report on a policy delphi study conducted in the Debian Project, one of the largest FOSS projects. Drawing from data collected in three phases from a panel of 21 experts, we identified 15 factors that affect their decision to adopt tools. This in turn can help FOSS communities to define a suitable policy of actions, in order to improve their processes.},
	keywords = {Delphi, Free/Open Source Software, Qualitative Study, study, tools},
	url = {https://www.researchgate.net/publication/291312269_How_Do_FreeOpen_Source_Developers_Pick_Their_Tools_A_Delphi_Study_of_the_Debian_Project},
	author = {Martin Krafft and Stol, Klaas-Jan and Fitzgerald, Brian}
}
@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 {1857,
	title = {Is there a wage premium for volunteer OSS engagement? {\textendash} signalling, learning and noise},
	journal = {Applied Economics},
	year = {2016},
	month = {09/2016},
	pages = {1 - 16},
	publisher = {Routledge},
	abstract = {Volunteer-based open-source production has become a significant new model for the organization of software development. Economics often pictures this phenomenon as a case of signaling: Individuals engage in the volunteer programming of open-source software (OSS) as a labor-market signal resulting in a wage premium. Yet, this explanation could so far not be empirically tested. The present paper fills this gap by estimating an upper-bound composite wage premium of voluntary OSS contributions and by separating the potential signaling effect of OSS engagement from other effects. Although some 70\% of OSS contributors believe that OSS involvement benefits their careers, we find no actual labor market premium for OSS engagement. The presence of other motives such as fun of play or altruism render OSS contributions too noisy to function as a signal.},
	keywords = {open source software, peer production, signalling, voluntary work, wage formation},
	issn = {1466-4283},
	doi = {10.1080/00036846.2016.1218427},
	author = {Bitzer, J{\"u}rgen and Geishecker, Ingo and Schr{\"o}der, Philipp J. H.}
}
@article {1802,
	title = {Candoia: A Platform and an Ecosystem for Building and Deploying Versatile Mining Software Repositories Tools},
	year = {2015},
	note = {" In terms of its focus,
the Candoia platform is closer to Bevan et al.{\textquoteright}s Kenyon [9],
Bajracharya et al.{\textquoteright}s Sourcerer [6], Gousios and Spinellis{\textquoteright}s Alitheia
Core [32, 31], Howison et al.{\textquoteright}s FLOSSMole [39] and different from
Boetticher et al.{\textquoteright}s PROMISE Repository [69], Gonz{\'a}lez-Barahona
and Robles{\textquoteright}s open-access data repositories [29], Black Duck OpenHub
(aka Ohloh) [13], GHTorrent [30, 33], Ossher et al.{\textquoteright}s SourcererDB
[64], the SourceForge Research Data Archive (SRDA) [28],
and Boa [25]. },
	month = {11/2015},
	institution = {Iowa State University},
	abstract = {Research on mining software repositories (MSR) has shown great
promise during the last decade in solving many challenging software
engineering problems. There exists, however, a {\textquoteleft}valley of death{\textquoteright}
between these significant innovations in the MSR research and their
deployment in practice. The significant cost of converting a prototype
to software; need to provide support for a wide variety of tools
and technologies e.g. CVS, SVN, Git, Bugzilla, Jira, Issues, etc,
to improve applicability; and the high cost of customizing tools to
practitioner-specific settings are some key hurdles in transition to
practice. We describe Candoia, a platform and an ecosystem that
is aimed at bridging this valley of death between innovations in
MSR research and their deployment in practice. We have implemented
Candoia and provide facilities to build and publish MSR
ideas as Candoia apps. Our evaluation demonstrates that Candoia
drastically reduces the cost of converting an idea to an app, thus
reducing the barrier to transitioning research findings into practice.
We also see versatility, in Candoia app{\textquoteright}s ability to work with a variety
of tools and technologies that the platform supports. Finally,
we find that customizing Candoia app to fit project-specific needs
is often well within the grasp of developers.},
	keywords = {Analysis of software and its evolution, Application specific development environments, flossmole cited, msr, research to practice, software evolution, software repositories},
	url = {http://lib.dr.iastate.edu/cgi/viewcontent.cgi?article=1378\&context=cs_techreports},
	attachments = {https://flosshub.org/sites/flosshub.org/files/Candoia-\%20A\%20Platform\%20and\%20an\%20Ecosystem\%20for\%20Building\%20and\%20Deploying\%20V.pdf},
	author = {Nitin M. Tiwari and Dalton D. Mills and Ganesha Upadhyaya and Eric Lin and Rajan, Hridesh}
}
@proceedings {1772,
	title = {An Empirical Study of Architectural Change in Open-Source Software Systems},
	year = {2015},
	month = {05/2015},
	publisher = {IEEE},
	abstract = {From its very inception, the study of software
architecture has recognized architectural decay as a regularly
occurring phenomenon in long-lived systems. Architectural decay
is caused by repeated changes to a system during its lifespan.
Despite decay{\textquoteright}s prevalence, there is a relative dearth of empirical
data regarding the nature of architectural changes that may lead
to decay, and of developers{\textquoteright} understanding of those changes. In
this paper, we take a step toward addressing that scarcity by
conducting an empirical study of changes found in software
architectures spanning several hundred versions of 14 opensource
systems. Our study reveals several new findings regarding
the frequency of architectural changes in software systems, the
common points of departure in a system{\textquoteright}s architecture during
maintenance and evolution, the difference between system-level
and component-level architectural change, and the suitability
of a system{\textquoteright}s implementation-level structure as a proxy for its
architecture.},
	keywords = {architectural change, architecture recovery, open-source systems, software architecture, software evolution},
	url = {http://softarch.usc.edu/~pooyan/publications/emparch_msr15.pdf},
	attachments = {https://flosshub.org/sites/flosshub.org/files/emparch_msr15.pdf},
	author = {Duc Minh Le and Pooyan Behnamghader and Joshua Garcia{\textdaggerdbl} Daniel Link and Arman Shahbazian and Nenad Medvidovic}
}
@article {1746,
	title = {Evaluation of FLOSS by Analyzing Its Software Evolution:},
	journal = {Journal of Information Technology Research},
	volume = {8},
	year = {2015},
	month = {01/2015},
	pages = {62 - 81},
	abstract = {In today{\textquoteright}s world, management often rely on FLOSS (Free/Libre/Open Source Software) systems to run their organizations. However, the nature of FLOSS is different from the software they have been using in the last decades. Its development model is distributed, and its authors are diverse as many volunteers and companies may collaborate in the project. In this paper, we want to shed some light on how to evaluate a FLOSS system by looking at the Moodle platform, which is currently the most used learning management system among educational institutions worldwide. In contrast with other evaluation models that have been proposed so far, the one we present is based on retrieving historical information that can be obtained publicly from the Internet, allowing us to study its evolution. As a result, we will show how by using our methodology management can take informed decisions that lower the risk that organizations face when investing in a FLOSS system.  },
	keywords = {free software, LMS, moodle, open source, software engineering, software evaluation, software evolution},
	issn = {1938-7865},
	doi = {10.4018/JITR.2015010105},
	attachments = {https://flosshub.org/sites/flosshub.org/files/Evaluation\%20of\%20FLOSS\%20by\%20Analyzing\%20its\%20Software\%20Evolution\%20-\%20An\%20Example\%20Using\%20the\%20Moodle\%20Platform.pdf},
	author = {Macho, H{\'e}ctor J. and Gregorio Robles and Gonz{\'a}lez-Barahona, Jesus M}
}
@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}
}
@proceedings {1755,
	title = {Mining StackOverflow to Filter out Off-topic IRC Discussion},
	year = {2015},
	month = {05/2015},
	abstract = {Internet Relay Chat (IRC) is a commonly used
tool by OpenSource developers. Developers use IRC channels
to discuss programming related problems, but much of the
discussion is irrelevant and off-topic. Essentially if we treat IRC
discussions like email messages, and apply spam filtering, we can
try to filter out the spam (the off-topic discussions) from the ham
(the programming discussions). Yet we need labelled data that
unfortunately takes time to curate.
To avoid costly curration in order to filter out off-topic
discussions, we need positive and negative data-sources. Online
discussion forums, such as StackOverflow, are very effective
for solving programming problems. By engaging in open-data,
StackOverflow data becomes a powerful source of labelled text
regarding programming. This work shows that we can train
classifiers using StackOverflow posts as positive examples of
on-topic programming discussion. YouTube video comments,
notorious for their lack of quality, serve as training set of offtopic
discussion. By exploiting these datasets, accurate classifiers
can be built, tested and evaluated that require very little effort
for end-users to deploy and exploit.},
	keywords = {irc, Stack Overflow, youtube},
	attachments = {https://flosshub.org/sites/flosshub.org/files/shaiful-mining_so_0.pdf},
	author = {Shaiful Alam Chowdhury and Hindle, Abram}
}
@conference {barcomb:2015:multiple,
	title = {A multiple case study of small free software businesses as social entrepreneurships},
	booktitle = {Proceedings of the 11th International Symposium on Open Collaboration (OpenSym 2015)},
	year = {2015},
	abstract = {Free/libre and open source software are frequently described as a single community or movement. The difference between free software and open source ideology may influence founders, resulting in different types of companies being created. Specifically, the relationship between free/libre software ideology and social entrepreneurships is investigated. This paper presents seven case studies of businesses, five of which were founded by people who  identify with the free/libre software movement. The result is a theory that small businesses founded by free/libre software advocates have three characteristics of social entrepreneurships. First, social benefit is prioritized over wealth creation. Second, the business{\textquoteright}s social mission is not incidental but is furthered through its for-profit activities, rather than supported by the company{\textquoteright}s profits. Third, the company{\textquoteright}s success is defined in part by the success of its social mission Free/libre software entrepreneurs who recognize their activities as social entrepreneurships can benefit from the existing literature on the unique challenges faced by socially-oriented businesses.},
	keywords = {free software, open source software, public good, small business, social entrepreneurship, social ventures},
	url = {https://opus4.kobv.de/opus4-fau/frontdoor/index/index/docId/6334},
	attachments = {https://flosshub.org/sites/flosshub.org/files/p100-barcomb.pdf},
	author = {Barcomb, Ann}
}
@inbook {1740,
	title = {The RISCOSS Platform for Risk Management in Open Source Software Adoption},
	booktitle = {Open Source Systems: Adoption and Impact},
	series = {IFIP Advances in Information and Communication Technology},
	volume = {451},
	year = {2015},
	pages = {124-133},
	publisher = {Springer International Publishing},
	organization = {Springer International Publishing},
	abstract = {Managing risks related to OSS adoption is a must for organizations that need to smoothly integrate OSS-related practices in their development processes. Adequate tool support may pave the road to effective risk management and ensure the sustainability of such activity. In this paper, we present the RISCOSS platform for managing risks in OSS adoption. RISCOSS builds upon a highly configurable data model that allows customization to several types of scopes. It implements two different working modes: exploration, where the impact of decisions may be assessed before making them; and continuous assessment, where risk variables (and their possible consequences on business goals) are continuously monitored and reported to decision-makers. The blackboard-oriented architecture of the platform defines several interfaces for the identified techniques, allowing new techniques to be plugged in.
},
	keywords = {Open source adoption, Open Source Projects, open source software, OSS, Risk Management, Software platform},
	isbn = {978-3-319-17836-3},
	doi = {10.1007/978-3-319-17837-0_12},
	url = {http://dx.doi.org/10.1007/978-3-319-17837-0_12},
	author = {Franch, X. and Kenett, R. and Mancinelli, F. and Susi, A. and Ameller, D. and Annosi, M.C. and Ben-Jacob, R. and Blumenfeld, Y. and Franco, O.H. and Gross, D. and Lopez, L. and Morandini, M. and Oriol, M. and Siena, A.},
	editor = {Damiani, Ernesto and Frati, Fulvio and Dirk Riehle and Wasserman, Anthony I.}
}
@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.}
}
@proceedings {1715,
	title = {"Should we move to Stack Overflow?" Measuring the utility of social media for developer support},
	year = {2015},
	month = {05/2015},
	pages = {10pp},
	publisher = {IEEE},
	abstract = {Stack Overflow is an enormously popular question-and-answer web site intended for software developers to help each other with programming issues. Some software projects aimed at developers (for example, application programming interfaces, application engines, cloud services, development frameworks, and the like) are closing their self-supported developer discussion forums and mailing lists and instead directing developers to use special-purpose tags on Stack Overflow. The goals of this paper are to document the main reasons given for moving developer support to Stack Overflow, and then to collect and analyze data from a group of software projects that have done this, in order to show whether the expected quality of support was actually achieved. The analysis shows that for all four software projects in this study, two of the desired quality indicators, developer participation and response time, did show improvements on Stack Overflow as compared to mailing lists and forums. However, we also found several projects that moved back from Stack Overflow, despite achieving these desired improvements. The results of this study are applicable to a wide variety of software projects that provide developer support using social media.},
	keywords = {developer support, forums, mailing list, metrics, quality, social media, Stack Overflow, technical support},
	attachments = {https://flosshub.org/sites/flosshub.org/files/SEIP2015stackv2.pdf},
	author = {Squire, Megan}
}
@inbook {1737,
	title = {Smart Route Planning Using Open Data and Participatory Sensing},
	booktitle = {Open Source Systems: Adoption and Impact},
	series = {IFIP Advances in Information and Communication Technology},
	volume = {451},
	year = {2015},
	pages = {91-100},
	publisher = {Springer International Publishing},
	organization = {Springer International Publishing},
	abstract = {Smart cities are not merely the infusion of technology into a city{\textquoteright}s infrastructure, but also require citizens interacting with their urban environment in a smart and informed manner. Transportation is key aspect of smart cities. In this paper, we present a smart route planning open-source system; SMART-GH utilizes open data and participatory sensing, where citizens actively participate in collecting data about the city in their daily environment, e.g., noise, air pollution, etc. SMART-GH then augments the routing logic with sensor data to answer queries such as {\textquoteleft}return the least noisy route{\textquoteright}. SMART-GH enables citizens to make smarter decisions about their daily commute, and subsequently improve their quality of life.
},
	keywords = {Open-data, open-source, Participatory sensing, Smart-city-routing},
	isbn = {978-3-319-17836-3},
	doi = {10.1007/978-3-319-17837-0_9},
	url = {http://dx.doi.org/10.1007/978-3-319-17837-0_9},
	attachments = {https://flosshub.org/sites/flosshub.org/files/nallur15.pdf},
	author = {Nallur, Vivek and Elgammal, Amal and Clarke, Siobh{\'a}n},
	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}
}
@inbook {1739,
	title = {Surveying the Adoption of FLOSS by Public Administration Local Organizations},
	booktitle = {Open Source Systems: Adoption and Impact},
	series = {IFIP Advances in Information and Communication Technology},
	volume = {451},
	year = {2015},
	pages = {114-123},
	publisher = {Springer International Publishing},
	organization = {Springer International Publishing},
	abstract = {Background. The introduction of Open Source Software technologies in the Public Administration plays a key role in the spread of Open Source Software. The state of the art in the adoption of Open Source Software solutions in the Public Administration is not very well known even in areas like Lombardy, which is Italy{\textquoteright}s largest and most developed region.
Goal. The goal of the investigation documented in this paper is to obtain a clear picture about the introduction of Open Source Software technologies in the Public Administration, the obstacles to their adoption, and the willingness of stakeholders to proceed with their introduction.
Method. We carried out a qualitative and quantitative survey that was submitted to a representative part of the Public Administrations in Lombardy.
Results. The analysis of the qualitative and quantitative information shows that several Public Administrations are already using Open Source Software technologies, though not in all application areas. The savings are one frequently cited incentive to the adoption of Open Source Software. However, one obstacle is the fact that a comprehensive law on software in the Public Administration has not yet been approved.
Conclusions. Our analysis provides results that indicate a common understanding of incentives, obstacles, and opportunities for Open Source Software technologies in Public Administrations.},
	keywords = {FLOSS adoption, Italy, Public administrations, Survey},
	isbn = {978-3-319-17836-3},
	doi = {10.1007/978-3-319-17837-0_11},
	url = {http://dx.doi.org/10.1007/978-3-319-17837-0_11},
	author = {Tosi, Davide and Lavazza, Luigi and Morasca, Sandro and Chiappa, Marco},
	editor = {Damiani, Ernesto and Frati, Fulvio and Dirk Riehle and Wasserman, Anthony I.}
}
@inbook {1736,
	title = {A Systematic Approach for Evaluating BPM Systems: Case Studies on Open Source and Proprietary Tools},
	booktitle = {Open Source Systems: Adoption and Impact},
	series = {IFIP Advances in Information and Communication Technology},
	volume = {451},
	year = {2015},
	pages = {81-90},
	publisher = {Springer International Publishing},
	organization = {Springer International Publishing},
	abstract = {Business Process Management Systems (BPMS) provide support for modeling, developing, deploying, executing and evaluating business processes in an organization. Selecting a BPMS is not a trivial task, not only due to the many existing alternatives, both in the open source and proprietary realms, but also because it requires a thorough evaluation of its capabilities, contextualizing them in the organizational environment in which they will be used. In this paper we present a methodology to guide the systematic evaluation of BPMS that takes into account the specific needs of each organization. It provides a list of key characteristics of BPMS which are ranked by the organization and evaluated using test cases and quantitative criteria. We also present case studies of open source and proprietary BPMS evaluations following our proposal.
},
	keywords = {Business Process Management Systems (BPMS), Evaluation methodology, Open source and proprietary BPMS, Systematic approach},
	isbn = {978-3-319-17836-3},
	doi = {10.1007/978-3-319-17837-0_8},
	url = {http://dx.doi.org/10.1007/978-3-319-17837-0_8},
	author = {Delgado, Andrea and Calegari, Daniel and Milanese, Pablo and Falcon, Renatta and Garc{\'\i}a, Esteban},
	editor = {Damiani, Ernesto and Frati, Fulvio and Dirk Riehle and Wasserman, Anthony I.}
}
@inbook {1614,
	title = {The Agile Management of Development Projects of Software Combining Scrum, Kanban and Expert Consultation},
	booktitle = {Open Source Software: Mobile Open Source Technologies},
	series = {IFIP Advances in Information and Communication Technology},
	volume = {427},
	year = {2014},
	pages = {176-180},
	publisher = {Springer Berlin Heidelberg},
	organization = {Springer Berlin Heidelberg},
	abstract = {

At the University of Informatics Sciences (UCI), Havana, Cuba, it is found The Center of Free Solutions of Software (CESOL) who has an informatic project named {\textquotedblleft}Auditing of Source Code{\textquotedblright} (ACF). This project has as objective to develop an open source software solution to auditing the source code of several software solutions with an agile projects management. In the present investigation have been showed the experiences obtained in the mixed application of two methods of agile projects management; Kanban and Scrum, together with the method Judgment of Expert, during the stage of construction of the lifecycle of ACF, when it is was performed a quality auditing by specialists of the CALISOFT company. In the auditing were detected several errors and to resolve them was necessary to estimate efforts, time and to revalue the lifecycle of the project. Moreover, the investigation show how this method can be used as a guide for young project managers for a correct planification and how can be used as a personal organizational method.
},
	keywords = {Agile management of projects, kanban, scrum},
	isbn = {978-3-642-55127-7},
	doi = {10.1007/978-3-642-55128-4_25},
	url = {http://dx.doi.org/10.1007/978-3-642-55128-4_25},
	author = {Febles Parker, MichelEvaristo and Monte, YusleydiFern{\'a}ndez},
	editor = {Corral, Luis and Sillitti, Alberto and Succi, Giancarlo and Vlasenko, Jelena and Wasserman, AnthonyI.}
}
@conference {Mitropoulos:2014:BCM:2597073.2597123,
	title = {The Bug Catalog of the Maven Ecosystem},
	booktitle = {Proceedings of the 11th Working Conference on Mining Software Repositories},
	series = {MSR 2014},
	year = {2014},
	pages = {372{\textendash}375},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {Examining software ecosystems can provide the research community with data regarding artifacts, processes, and communities. We present a dataset obtained from the Maven central repository ecosystem (approximately 265GB of data) by statically analyzing the repository to detect potential software bugs. For our analysis we used FindBugs, a tool that examines Java bytecode to detect numerous types of bugs. The dataset contains the metrics results that FindBugs reports for every project version (a JAR) included in the ecosystem. For every version we also stored specific metadata such as the JAR{\textquoteright}s size, its dependencies and others. Our dataset can be used to produce interesting research results, as we show in specific examples.
},
	keywords = {findbugs, Maven Repository, msr data showcase, Software Bugs},
	isbn = {978-1-4503-2863-0},
	doi = {10.1145/2597073.2597123},
	url = {http://doi.acm.org/10.1145/2597073.2597123},
	attachments = {https://flosshub.org/sites/flosshub.org/files/mitro.pdf},
	author = {Mitropoulos, Dimitris and Vassilios Karakoidas and Louridas, Panos and Gousios, Georgios and Diomidis Spinellis}
}
@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 {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 {Saini:2014:DMA:2597073.2597134,
	title = {A Dataset for Maven Artifacts and Bug Patterns Found in Them},
	booktitle = {Proceedings of the 11th Working Conference on Mining Software Repositories},
	series = {MSR 2014},
	year = {2014},
	pages = {416{\textendash}419},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {In this paper, we present data downloaded from Maven, one of the most popular component repositories. The data includes the binaries of 186,392 components, along with source code for 161,025. We identify and organize these components into groups where each group contains all the versions of a library. In order to asses the quality of these components, we make available report generated by the FindBugs tool on 64,574 components. The information is also made available in the form of a database which stores total number, type, and priority of bug patterns found in each component, along with its defect density. We also describe how this dataset can be useful in software engineering research.
},
	keywords = {Empirical Research, Empirical software engineering, findbugs, maven, software quality},
	isbn = {978-1-4503-2863-0},
	doi = {10.1145/2597073.2597134},
	url = {http://doi.acm.org/10.1145/2597073.2597134},
	author = {Saini, Vaibhav and Sajnani, Hitesh and Ossher, Joel and Lopes, Cristina V.}
}
@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.}
}
@conference {Wu:2014:EES:2556420.2556483,
	title = {Exploring the Ecosystem of Software Developers on GitHub and Other Platforms},
	booktitle = {Proceedings of the Companion Publication of the 17th ACM Conference on Computer Supported Cooperative Work \&\#38; Social Computing},
	series = {CSCW Companion {\textquoteright}14},
	year = {2014},
	pages = {265{\textendash}268},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {GitHub provides various social features for developers to collaborate with others. Those features are important for developers to coordinate their work (Dabbish et al., 2012; Marlow et al., 2013). We hypothesized that the social system of GitHub users was bound by system interactions such that contributing to similar code repositories would lead to users following one another on GitHub or vice versa. Using a quadratic assignment procedure (QAP) correlation, however, only a weak correlation among followship and production activities (code, issue, and wiki contributions) was found. Survey with GitHub users revealed an ecosystem on the Internet for software developers, which includes many platforms, such as Forrst, Twitter, and Hacker News, among others. Developers make social introductions and other interactions on these platforms and engage with one anther on GitHub. Due to these preliminary findings, we describe GitHub as a part of a larger ecosystem of developer interactions.
},
	keywords = {ecosystem, follow, github, social connection},
	isbn = {978-1-4503-2541-7},
	doi = {10.1145/2556420.2556483},
	url = {http://doi.acm.org/10.1145/2556420.2556483},
	author = {Wu, Yu and Kropczynski, Jessica and Shih, Patrick C. and Carroll, John M.}
}
@conference {Robles:2014:FSD:2597073.2597129,
	title = {FLOSS 2013: A Survey Dataset About Free Software Contributors: Challenges for Curating, Sharing, and Combining},
	booktitle = {Proceedings of the 11th Working Conference on Mining Software Repositories},
	series = {MSR 2014},
	year = {2014},
	pages = {396{\textendash}399},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {In this data paper we describe a data set obtained by means of performing an on-line survey to over 2,000 Free Libre Open Source Software (FLOSS) contributors. The survey includes questions related to personal characteristics (gender, age, civil status, nationality, etc.), education and level of English, professional status, dedication to FLOSS projects, reasons and motivations, involvement and goals. We describe as well the possibilities and challenges of using private information from the survey when linked with other, publicly available data sources. In this regard, an example of data sharing will be presented and legal, ethical and technical issues will be discussed.
},
	keywords = {anonymization, data combining, data sharing, ethics, free software, microdata, msr data showcase, open data, open source, privacy, Survey},
	isbn = {978-1-4503-2863-0},
	doi = {10.1145/2597073.2597129},
	url = {http://doi.acm.org/10.1145/2597073.2597129},
	attachments = {https://flosshub.org/sites/flosshub.org/files/msr14gregorio.pdf},
	author = {Gregorio Robles and Reina, Laura Arjona and Serebrenik, Alexander and Vasilescu, Bogdan and Gonz{\'a}lez-Barahona, Jes{\'u}s M.}
}
@inbook {1617,
	title = {Flow Research SXP Agile Methodology for FOSS Projects},
	booktitle = {Open Source Software: Mobile Open Source Technologies},
	series = {IFIP Advances in Information and Communication Technology},
	volume = {427},
	year = {2014},
	pages = {195-198},
	publisher = {Springer Berlin Heidelberg},
	organization = {Springer Berlin Heidelberg},
	abstract = {

This paper aims to explain a procedure that takes into account the different research processes carried out in developing an open-source, allowing control and management. This study is the SXP methodology applied in this type of project was carried out, allowing the validity of the basis of this research.
},
	keywords = {methodology SXP, open-source, production, research, Software},
	isbn = {978-3-642-55127-7},
	doi = {10.1007/978-3-642-55128-4_28},
	url = {http://dx.doi.org/10.1007/978-3-642-55128-4_28},
	author = {Pe{\~n}alver Romero, GladysMarsi and Leyva Samada, LisandraIsabel and Abad, AbelMeneses},
	editor = {Corral, Luis and Sillitti, Alberto and Succi, Giancarlo and Vlasenko, Jelena and Wasserman, AnthonyI.}
}
@inbook {1598,
	title = {FOSS Service Management and Incidences},
	booktitle = {Open Source Software: Mobile Open Source Technologies},
	series = {IFIP Advances in Information and Communication Technology},
	volume = {427},
	year = {2014},
	pages = {76-79},
	publisher = {Springer Berlin Heidelberg},
	organization = {Springer Berlin Heidelberg},
	abstract = {

The Free Open Source Software (FOSS) solutions have been reaching a high demand, usage and global recognition, not only in the development of applications for companies and institutions also in the management of services and incidents. With the upswing of Information Technology (IT), the development of tools that enable the reporting of problems and incidents on any organization or company is necessary. Every day you need more applications, software generally, that make easier the user{\textquoteright}s actions. This paper describes the need to use these tools and recount the development of a web application that allows the management of reports and incidents from users of Nova, the GNU/Linux Cuban distribution.
},
	keywords = {FOSS, service management and incidences},
	isbn = {978-3-642-55127-7},
	doi = {10.1007/978-3-642-55128-4_9},
	url = {http://dx.doi.org/10.1007/978-3-642-55128-4_9},
	author = {Ortiz, SusanaS{\'a}nchez and P{\'e}rez Benitez, Alfredo},
	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 {Zhang:2014:ISM:2666539.2666572,
	title = {Investigating Social Media in GitHub{\textquoteright}s Pull-requests: A Case Study on Ruby on Rails},
	booktitle = {Proceedings of the 1st International Workshop on Crowd-based Software Development Methods and Technologies},
	series = {CrowdSoft 2014},
	year = {2014},
	pages = {37{\textendash}41},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {In GitHub, pull-request mechanism is an outstanding social development method by integrating with many social media. Many studies have explored that social media has an important effect on software development. @-mention as a typical social media, is a useful tool in social platform. In this paper, we made a quantitative analysis of @-mention in pull-requests of the project Ruby on Rails. First, we make a convictive statistics of the popularity of pull-request mechanism in GitHub. Then we investigate the current situation of @-mention in the Ruby on Rails. Our empirical analysis results find some insights of @-mention.
},
	keywords = {@-mention, github, pull-request, social media},
	isbn = {978-1-4503-3224-8},
	doi = {10.1145/2666539.2666572},
	url = {http://doi.acm.org/10.1145/2666539.2666572},
	author = {Zhang, Yang and Yin, Gang and Yu, Yue and Wang, Huaimin}
}
@conference {Yamashita:2014:MSO:2597073.2597116,
	title = {Magnet or Sticky? An OSS Project-by-project Typology},
	booktitle = {Proceedings of the 11th Working Conference on Mining Software Repositories},
	series = {MSR 2014},
	year = {2014},
	pages = {344{\textendash}347},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {For Open Source Software (OSS) projects, retaining existing contributors and attracting new ones is a major concern. In this paper, we expand and adapt a pair of population migration metrics to analyze migration trends in a collection of open source projects. Namely, we study: (1) project stickiness, i.e., its tendency to retain existing contributors and (2) project magnetism, i.e., its tendency to attract new contributors. Using quadrant plots, we classify projects as attractive (highly magnetic and sticky), stagnant (highly sticky, weakly magnetic), fluctuating (highly magnetic, weakly sticky), or terminal (weakly magnetic and sticky). Through analysis of the MSR challenge dataset, we find that: (1) quadrant plots can effectively identify at-risk projects, (2) stickiness is often motivated by professional activity and (3) transitions among quadrants as a project ages often coincides with interesting events in the evolution history of a project.
},
	keywords = {Developer migration, Magnet, mining challenge, msr challenge, open source, Sticky},
	isbn = {978-1-4503-2863-0},
	doi = {10.1145/2597073.2597116},
	url = {http://doi.acm.org/10.1145/2597073.2597116},
	attachments = {https://flosshub.org/sites/flosshub.org/files/yamashita.pdf},
	author = {Yamashita, Kazuhiro and McIntosh, Shane and Kamei, Yasutaka and Ubayashi, Naoyasu}
}
@unpublished {1799,
	title = {Measuring the Health of Open Source Software Ecosystems: Moving Beyond the Scope of Project Health},
	year = {2014},
	abstract = {Background. The livelihood of an open source ecosystem is important to different ecosystem participants: software developers, end-users, investors, and participants want to know whether their ecosystem is healthy and performing well. Currently, there exists no working operationalization available that can be used to determine the health of open source ecosystems. Health is typically looked at from a project scope, not from an ecosystem scope. Objectives. With such an operationalization, stakeholders can make better decisions on whether to invest in an ecosystem: developers can select the healthiest ecosystem to join, keystone organizers can establish which governance techniques are effective, and end-users can select ecosystems that are robust, will live long, and prosper. Method. Design research is used to create the health operationalization. The evaluation step is done using four ecosystem health projects from literature. Results. The Open Source Ecosystem Health Operationalization is provided, which establishes the health of a complete software ecosystem, using the data from collections of open source projects that belong to the ecosystem. Conclusion. The groundwork is done, by providing a summary of research challenges, for more research in ecosystem health. With the operationalization in hand, re- searchers no longer need to start from scratch when researching open source ecosystems{\textquoteright} health.},
	keywords = {open source ecosystems, Software ecosystem health, Software repository mining},
	url = {https://www.dropbox.com/s/borc730uw32kkzp/SECOhealth.pdf?dl=0},
	attachments = {https://flosshub.org/sites/flosshub.org/files/SECOhealth\%20\%281\%29.pdf},
	author = {Slinger Jansen}
}
@conference {Eckhardt:2014:MMO:2642803.2642810,
	title = {The Merits of a Meritocracy in Open Source Software Ecosystems},
	booktitle = {Proceedings of the 2014 European Conference on Software Architecture Workshops},
	series = {ECSAW {\textquoteright}14},
	year = {2014},
	pages = {7:1{\textendash}7:6},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {The Eclipse open source ecosystem has grown from a small internal IBM project to one of the biggest Integrated Development Environments in the market. Open source communities and ecosystems do not follow the standard governance strategies typically used in large organizations. A meritocracy is a frequently occurring form of governance on different levels in open ecosystems. In this paper we investigate how this form of governance influences the health of projects within the Eclipse ecosystem in terms of the amount of commits within each month. We analyzed the hierarchy of Eclipse, how merits are conceptualized within the ecosystem and the effect of the appointments of mentors and project leads on the amount of commits. From our research, we can conclude that this system is not always as fair as it seems; merits are only a benefit in some cases.},
	keywords = {Ecosystem Health, Meritocracy, open source, Software ecosystems},
	isbn = {978-1-4503-2778-7},
	doi = {10.1145/2642803.2642810},
	url = {http://doi.acm.org/10.1145/2642803.2642810},
	author = {Eckhardt, Evert and Kaats, Erwin and Slinger Jansen and Alves, Carina}
}
@conference {Guo:2014:ODC:2597073.2597094,
	title = {Oops! Where Did That Code Snippet Come from?},
	booktitle = {Proceedings of the 11th Working Conference on Mining Software Repositories},
	series = {MSR 2014},
	year = {2014},
	pages = {52{\textendash}61},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {A kernel oops is an error report that logs the status of the Linux kernel at the time of a crash. Such a report can provide valuable first-hand information for a Linux kernel maintainer to conduct postmortem debugging. Recently, a repository has been created that systematically collects kernel oopses from Linux users. However, debugging based on only the information in a kernel oops is difficult. We consider the initial problem of finding the offending line, i.e., the line of source code that incurs the crash. For this, we propose a novel algorithm based on approximate sequence matching, as used in bioinformatics, to automatically pinpoint the offending line based on information about nearby machine-code instructions, as found in a kernel oops. Our algorithm achieves 92\% accuracy compared to 26\% for the traditional approach of using only the oops instruction pointer.},
	keywords = {debugging, linux kernel, oops, sequence alignment},
	isbn = {978-1-4503-2863-0},
	doi = {10.1145/2597073.2597094},
	url = {http://doi.acm.org/10.1145/2597073.2597094},
	attachments = {https://flosshub.org/sites/flosshub.org/files/guo.pdf},
	author = {Guo, Lisong and Lawall, Julia and Muller, Gilles}
}
@conference {Pletea:2014:SES:2597073.2597117,
	title = {Security and Emotion: Sentiment Analysis of Security Discussions on GitHub},
	booktitle = {Proceedings of the 11th Working Conference on Mining Software Repositories},
	series = {MSR 2014},
	year = {2014},
	pages = {348{\textendash}351},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {Application security is becoming increasingly prevalent during software and especially web application development. Consequently, countermeasures are continuously being discussed and built into applications, with the goal of reducing the risk that unauthorized code will be able to access, steal, modify, or delete sensitive data. In this paper we gauged the presence and atmosphere surrounding security-related discussions on GitHub, as mined from discussions around commits and pull requests. First, we found that security related discussions account for approximately 10\% of all discussions on GitHub. Second, we found that more negative emotions are expressed in security-related discussions than in other discussions. These findings confirm the importance of properly training developers to address security concerns in their applications as well as the need to test applications thoroughly for security vulnerabilities in order to reduce frustration and improve overall project atmosphere.
},
	keywords = {github, mining challenge, msr challenge, security, sentiment analysis},
	isbn = {978-1-4503-2863-0},
	doi = {10.1145/2597073.2597117},
	url = {http://doi.acm.org/10.1145/2597073.2597117},
	attachments = {https://flosshub.org/sites/flosshub.org/files/pletea.pdf},
	author = {Pletea, Daniel and Vasilescu, Bogdan and Serebrenik, Alexander}
}
@conference {Guzman:2014:SAC:2597073.2597118,
	title = {Sentiment Analysis of Commit Comments in GitHub: An Empirical Study},
	booktitle = {Proceedings of the 11th Working Conference on Mining Software Repositories},
	series = {MSR 2014},
	year = {2014},
	pages = {352{\textendash}355},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {Emotions have a high impact in productivity, task quality, creativity, group rapport and job satisfaction. In this work we use lexical sentiment analysis to study emotions expressed in commit comments of different open source projects and analyze their relationship with different factors such as used programming language, time and day of the week in which the commit was made, team distribution and project approval. Our results show that projects developed in Java tend to have more negative commit comments, and that projects that have more distributed teams tend to have a higher positive polarity in their emotional content. Additionally, we found that commit comments written on Mondays tend to a more negative emotion. While our results need to be confirmed by a more representative sample they are an initial step into the study of emotions and related factors in open source projects.
},
	keywords = {Human Factors in Software Engineering, mining challenge, msr challenge, sentiment analysis},
	isbn = {978-1-4503-2863-0},
	doi = {10.1145/2597073.2597118},
	url = {http://doi.acm.org/10.1145/2597073.2597118},
	author = {Guzman, Emitza and Az{\'o}car, David and Li, Yang}
}
@article {1745,
	title = {SENTIMENT ANALYSIS OF FREE/OPEN SOURCE DEVELOPERS: PRELIMINARY FINDINGS FROM A CASE STUDY},
	journal = {Revista Eletr{\^o}nica de Sistemas de Informa{\c c}{\~a}o},
	volume = {13},
	year = {2014},
	month = {08/2014},
	abstract = {Software development is a human intensive activity. And as such, how developers face their tasks is of major importance. In an environment such as the one that is common in FOSS (free/open source software) projects where professionals (i.e., paid developers) share the development effort with volunteers, the morale of the development and user community is of major importance. In this paper, we present a preliminary analysis using sentiment analysis techniques to a FOSS project. We therefore mine the mailing list of a project and apply these techniques to the most relevant participants. Although the application is at this time limited, we hope that this experience can be of benefit in the future to determine situations that may affect the developers or the project, such as low productivity, developer abandonment, project forking, etc. },
	keywords = {developer productivity, FLOSS, mailing lists, natural language processing, openSUSE, sentiment analysis, software development; software repository mining},
	doi = {10.5329/RESI.2014.1302006},
	url = {http://189.16.45.2/ojs/index.php/reinfo/article/view/1677},
	attachments = {https://flosshub.org/sites/flosshub.org/files/1677-6732-1-PB.pdf},
	author = {Rousinopoulos, Athanasios-Ilias and Gregorio Robles and Gonz{\'a}lez-Barahona, Jes{\'u}s M.}
}
@conference {Vasilescu:2014:SDH:2556420.2556833,
	title = {Software Developers Are Humans, Too!},
	booktitle = {Proceedings of the Companion Publication of the 17th ACM Conference on Computer Supported Cooperative Work \&\#38; Social Computing},
	series = {CSCW Companion {\textquoteright}14},
	year = {2014},
	pages = {97{\textendash}100},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {Open-source communities can be seen as knowledge-sharing ecosystems: participants learn from the community and from one another, and share their knowledge through contributions to the source code repositories or by offering support to users. With the emergence and growing popularity of social media sites targeting software developers (e.g., StackOverflow, GitHub), the paths through which knowledge flows within open-source software knowledge-sharing ecosystems are also beginning to change. My dissertation research seeks to raise our understanding of these changes.},
	keywords = {human aspects, open-source, software developers},
	isbn = {978-1-4503-2541-7},
	doi = {10.1145/2556420.2556833},
	url = {http://doi.acm.org/10.1145/2556420.2556833},
	author = {Vasilescu, Bogdan}
}
@article {thomas2014studying,
	title = {Studying software evolution using topic models},
	journal = {Science of Computer Programming},
	volume = {80},
	year = {2014},
	pages = {457{\textendash}479},
	publisher = {Elsevier},
	abstract = {Topic models are generative probabilistic models which have been applied to information
retrieval to automatically organize and provide structure to a text corpus. Topic models
discover topics in the corpus, which represent real world concepts by frequently cooccurring
words. Recently, researchers found topics to be effective tools for structuring
various software artifacts, such as source code, requirements documents, and bug reports.
This research also hypothesized that using topics to describe the evolution of software
repositories could be useful for maintenance and understanding tasks. However, research
has yet to determine whether these automatically discovered topic evolutions describe the
evolution of source code in a way that is relevant or meaningful to project stakeholders, and
thus it is not clear whether topic models are a suitable tool for this task.
In this paper, we take a first step towards evaluating topic models in the analysis of
software evolution by performing a detailed manual analysis on the source code histories
of two well-known and well-documented systems, JHotDraw and jEdit. We define and
compute various metrics on the discovered topic evolutions and manually investigate how
and why the metrics evolve over time. We find that the large majority (87\%{\textendash}89\%) of topic
evolutions correspond well with actual code change activities by developers. We are thus
encouraged to use topic models as tools for studying the evolution of a software system.},
	keywords = {Latent Dirichlet allocation, mining software repositories, software evolution, topic model},
	url = {http://sail.cs.queensu.ca/publications/pubs/Thomas-2012-SCP.pdf},
	author = {Stephen W. Thomas and Adams, Bram and Hassan, Ahmed E. and Blostein, Dorothea}
}
@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 {Sheoran:2014:UWG:2597073.2597114,
	title = {Understanding "Watchers" on GitHub},
	booktitle = {Proceedings of the 11th Working Conference on Mining Software Repositories},
	series = {MSR 2014},
	year = {2014},
	pages = {336{\textendash}339},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {Users on GitHub can watch repositories to receive notifications about project activity. This introduces a new type of passive project membership. In this paper, we investigate the behavior of watchers and their contribution to the projects they watch. We find that a subset of project watchers begin contributing to the project and those contributors account for a significant percentage of contributors on the project. As contributors, watchers are more confident and contribute over a longer period of time in a more varied way than other contributors. This is likely attributable to the knowledge gained through project notifications.
},
	keywords = {github, mining challenge, msr challenge, repositories, Software Teams, Watchers},
	isbn = {978-1-4503-2863-0},
	doi = {10.1145/2597073.2597114},
	url = {http://doi.acm.org/10.1145/2597073.2597114},
	author = {Sheoran, Jyoti and Blincoe, Kelly and Kalliamvakou, Eirini and Damian, Daniela and Ell, Jordan}
}
@inbook {1604,
	title = {Use of Open Software Tools for Data Offloading Techniques Analysis on Mobile Networks},
	booktitle = {Open Source Software: Mobile Open Source Technologies},
	series = {IFIP Advances in Information and Communication Technology},
	volume = {427},
	year = {2014},
	pages = {111-112},
	publisher = {Springer Berlin Heidelberg},
	organization = {Springer Berlin Heidelberg},
	abstract = {

This research aims to highlight the benefits of using free software based tools for studying a LTE mobile network with realistic parameters. We will overload this LTE network and offload it through data offloading techniques such as small cells and WiFi offload. For this research, discreteevent open software network simulator ns3 will be implemented. Ns3 is a network simulator based on the programming language C++, and has all the necessary libraries to simulate an LTE and WiFi network.
},
	keywords = {Data Offloading, LTE, ns3, OSS for research and education, small cells, WiFi},
	isbn = {978-3-642-55127-7},
	doi = {10.1007/978-3-642-55128-4_15},
	url = {http://dx.doi.org/10.1007/978-3-642-55128-4_15},
	author = {Koo, Jos{\'e}M. and Espino, JuanP. and Armuelles, Iv{\'a}n and Villarreal, Rub{\'e}n},
	editor = {Corral, Luis and Sillitti, Alberto and Succi, Giancarlo and Vlasenko, Jelena and Wasserman, AnthonyI.}
}
@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}
}
@inbook {1626,
	title = {When Are OSS Developers More Likely to Introduce Vulnerable Code Changes? A Case Study},
	booktitle = {Open Source Software: Mobile Open Source Technologies},
	series = {IFIP Advances in Information and Communication Technology},
	volume = {427},
	year = {2014},
	pages = {234-236},
	publisher = {Springer Berlin Heidelberg},
	organization = {Springer Berlin Heidelberg},
	abstract = {

We analyzed peer code review data of the Android Open Source Project (AOSP) to understand whether code changes that introduce security vulnerabilities, referred to as vulnerable code changes (VCC), occur at certain intervals. Using a systematic manual analysis process, we identified 60 VCCs. Our results suggest that AOSP developers were more likely to write VCCs prior to AOSP releases, while during the post-release period they wrote fewer VCCs.
},
	keywords = {FOSS, open source, OSS, security, vulnerability},
	isbn = {978-3-642-55127-7},
	doi = {10.1007/978-3-642-55128-4_37},
	url = {http://dx.doi.org/10.1007/978-3-642-55128-4_37},
	author = {Bosu, Amiangshu and Carver, JeffreyC. and Hafiz, Munawar and Hilley, Patrick and Janni, Derek},
	editor = {Corral, Luis and Sillitti, Alberto and Succi, Giancarlo and Vlasenko, Jelena and Wasserman, AnthonyI.}
}
@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}
}
@conference {Paschalidou:2013:ADE:2490257.2490264,
	title = {An application of data envelopment analysis to software quality assessment},
	booktitle = {Proceedings of the 6th Balkan Conference in Informatics},
	series = {BCI {\textquoteright}13},
	year = {2013},
	pages = {228{\textendash}235},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {Data Envelopment Analysis (DEA) is a non-parametric technique which involves the use of linear programming methods to measure the efficiency of a homogenous set of units. These units are known as Decision Making Units (DMUs) and defined by multiple input and output data. Efficiencies are measured relative to a piece-wise surface (efficient frontier) which envelops the data, thus justifying the name of the technique. Although DEA has been mostly used in production economics, its application in the context of software quality evaluation seems to be a promising approach. This study provides an application of DEA to assess the evolution of two open-source software projects in terms of selected metric values for successive versions of each project. What is really interesting in DEA is that a single efficiency score is calculated for each version despite the often convoluted overall picture of the metric values. According to a simplified view of DEA, there are two categories of units, the efficient (onto the efficient frontier) and the inefficient ones. Each inefficient unit is characterized by a reference set of peers which involves all the efficient units "operating" closer to that unit. Through the consideration of the reference set of the inefficient versions of each project, the metrics that require improvement, as well as the extent of improvement, could be estimated. These results could assist software developers in identifying design issues that require further improvement. Notwithstanding the fact that there are a number of issues to be further investigated, the applicability of DEA and other operations research tools in the context of software quality might yield interesting results.
},
	keywords = {dea, design metrics, software evolution, software quality},
	isbn = {978-1-4503-1851-8},
	doi = {10.1145/2490257.2490264},
	url = {http://doi.acm.org/10.1145/2490257.2490264},
	author = {Paschalidou, Georgia and Stiakakis, Emmanouil and Chatzigeorgiou, Alexander}
}
@proceedings {1522,
	title = {Boa: A Language and Infrastructure for Analyzing Ultra-Large-Scale Software Repositories},
	year = {2013},
	month = {05/2013},
	pages = {422-431},
	abstract = {In today{\textquoteright}s software-centric world, ultra-large-scale software repositories, e.g. SourceForge (350,000+ projects), GitHub (250,000+ projects), and Google Code (250,000+ projects) are the new library of Alexandria. They contain an enormous corpus of software and information about software. Scientists and engineers alike are interested in analyzing this wealth of information both for curiosity as well as for testing important hypotheses. However, systematic extraction of relevant data from these repositories and analysis of such data for testing hypotheses is hard, and best left for mining software repository (MSR) experts! The goal of Boa, a domain-specific language and infrastructure described here, is to ease testing MSR-related hypotheses. We have implemented Boa and provide a web-based interface to Boa{\textquoteright}s infrastructure. Our evaluation demonstrates that Boa substantially reduces programming efforts, thus lowering the barrier to entry. We also see drastic improvements in scalability. Last but not least, reproducing an experiment conducted using Boa is just a matter of re-running small Boa programs provided by previous researchers.},
	keywords = {ease of use, forge, github, google code, lower barrier to entry, mining, repository, reproducible, scalable, Software, sourceforge},
	author = {Dyer, Robert and Nguyen, Hoan Anh and Rajan, Hridesh and Nguyen, Tien N.}
}
@conference {Venkataramani:2013:DTE:2487788.2487832,
	title = {Discovery of Technical Expertise from Open Source Code Repositories},
	booktitle = {Proceedings of the 22Nd International Conference on World Wide Web Companion},
	series = {WWW {\textquoteright}13 Companion},
	year = {2013},
	pages = {97{\textendash}98},
	publisher = {International World Wide Web Conferences Steering Committee},
	organization = {International World Wide Web Conferences Steering Committee},
	address = {Republic and Canton of Geneva, Switzerland},
	abstract = {Online Question and Answer websites for developers have emerged as the main forums for interaction during the software development process. The veracity of an answer in such websites is typically verified by the number of {\textquoteright}upvotes{\textquoteright} that the answer garners from peer programmers using the same forum. Although this mechanism has proved to be extremely successful in rating the usefulness of the answers, it does not lend itself very elegantly to model the expertise of a user in a particular domain. In this paper, we propose a model to rank the expertise of the developers in a target domain by mining their activity in different opensource projects. To demonstrate the validity of the model, we built a recommendation system for StackOverflow which uses the data mined from GitHub.
},
	keywords = {github, knowledge discovery, recommendations, source code repository, stackoverflow, technical expertise},
	isbn = {978-1-4503-2038-2},
	url = {http://dl.acm.org/citation.cfm?id=2487788.2487832},
	author = {Venkataramani, Rahul and Gupta, Atul and Asadullah, Allahbaksh and Muddu, Basavaraju and Bhat, Vasudev}
}
@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.}
}
@book {1532,
	title = {How Healthy Is My Project? Open Source Project Attributes as Indicators of Success},
	series = {IFIP Advances in Information and Communication Technology Open Source Software: Quality Verification},
	volume = {404},
	year = {2013},
	note = {"The dataset used has thus been obtained through a third source which has made
the data publicly available [18]. FlossMole.org contains data collected for the period
2006 to December 2009 from which a dataset was compiled of 125,700 projects. "},
	pages = {30 - 44},
	publisher = {Springer Berlin Heidelberg},
	organization = {Springer Berlin Heidelberg},
	address = {Berlin, Heidelberg},
	abstract = {Determining what factors can influence the successful outcome of a software project has been labeled by many scholars and software engineers as a difficult problem. In this paper we use machine learning to create a model that can determine the stage a software project has obtained with some accuracy. Our model uses 8 Open Source project metrics to determine the stage a project is in. We validate our model using two performance measures; the exact success rate of classifying an Open Source Software project and the success rate over an interval of one stage of its actual performance using different scales of our dependent variable. In all cases we obtain an accuracy of above 70\% with one away classification (a classification which is away by one) and about 40\% accuracy with an exact classification. We also determine the factors (according to one classifier) that uses only eight variables among all the variables available in SourceForge, that determine the health of an OSS project.
},
	keywords = {flossmole, sourceforge},
	isbn = {978-3-642-38928-3},
	issn = {1868-422X},
	doi = {10.1007/978-3-642-38928-3_3},
	url = {http://link.springer.com/chapter/10.1007/978-3-642-38928-3_3},
	attachments = {https://flosshub.org/sites/flosshub.org/files/OSSHealth_1.0.pdf},
	author = {Piggot, James and Amrit, Chintan},
	editor = {Petrinja, Etiel and Succi, Giancarlo and Ioini, Nabil and Sillitti, Alberto}
}
@book {1531,
	title = {Is It All Lost? A Study of Inactive Open Source Projects},
	series = {IFIP Advances in Information and Communication Technology Open Source Software: Quality Verification },
	volume = {404},
	year = {2013},
	pages = {61 - 79},
	publisher = {Springer Berlin Heidelberg},
	organization = {Springer Berlin Heidelberg},
	address = {Berlin, Heidelberg},
	abstract = {
Open Source Software (OSS) proponents suggest that when developers lose interest in their project, their last duty is to {\textquotedblleft}hand it off to a competent successor.{\textquotedblright} However, the mechanisms of such a hand-off are not clear, or widely known among OSS developers. As a result, many OSS projects, after a certain long period of evolution, stop evolving, in fact becoming {\textquotedblleft}inactive{\textquotedblright} or {\textquotedblleft}abandoned{\textquotedblright} projects. This paper presents an analysis of the population of projects contained within one of the largest OSS repositories available (SourceForge.net), in order to describe how projects abandoned by their developers can be identified, and to discuss the attributes and characteristics of these inactive projects. In particular, the paper attempts to differentiate projects that experienced maintainability issues from those that are inactive for other reasons, in order to be able to correlate common characteristics to the {\textquotedblleft}failure{\textquotedblright} of these projects.
},
	keywords = {sourceforge},
	isbn = {978-3-642-38928-3},
	issn = {1868-422X},
	doi = {10.1007/978-3-642-38928-3_5},
	url = {http://staff.lero.ie/stol/files/2013/03/2013-Is-It-All-Lost-A-Study-of-Inactive-Open-Source-Projects.pdf},
	attachments = {https://flosshub.org/sites/flosshub.org/files/2013-Is-It-All-Lost-A-Study-of-Inactive-Open-Source-Projects.pdf},
	author = {Khondu, Jymit and Capiluppi, Andrea and Stol, Klaas},
	editor = {Petrinja, Etiel and Succi, Giancarlo and Ioini, Nabil and Sillitti, Alberto}
}
@conference {abdouSEKE2013,
	title = {{Managing Corrective Actions to Closure in Open Source Software Test Process}},
	booktitle = {The 25th International Conference on Software Engineering and Knowledge Engineering (SEKE 2013)},
	year = {2013},
	pages = {306{\textendash}311},
	address = {Boston, USA},
	abstract = {In assessing test process maturity, one of the goals is to manage disciplinary issues. Managing corrective actions to closure is known to aid software quality assurance, in general, and testing process activities, in particular. In this paper, a framework for software testing assessment, namely OSS-TPA, that aims to evaluate corrective actions in OSS test process, is proposed. The OSS-TPA framework is based on earlier studies and relies on a conceptual model for test process activities in OSS development. Using success factors in OSS development, the relationship between the maturity of managing corrective actions and the adoption of OSS is investigated.},
	keywords = {open source software, software engineering, software quality, Software testing, Test Process Improvement.},
	url = {http://index.ksi.edu/conf/seke/2013/cr/282.pdf},
	attachments = {https://flosshub.org/sites/flosshub.org/files/282.pdf},
	author = {Abdou, Tamer and Grogono, Peter and Kamthan, Pankaj}
}
@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 {1515,
	title = {Using Citation Influence to Predict Software Defects},
	year = {2013},
	month = {05/2013},
	abstract = {The software dependency network reflects structure and the developer contribution network reflects process. Previous studies have used social network properties over these networks to predict whether a software component is defect-prone. However, these studies do not consider the strengths of the dependencies in the networks. In our approach, we use a citation influence topic model to determine dependency strengths among components and developers, analyze weak and strong dependencies separately, and apply social network properties to predict defect-prone components. In experiments on Eclipse and NetBeans, our approach has higher accuracy than prior work.},
	keywords = {eclipse, netbeans, social network},
	author = {Wei Hu and Kenny Wong}
}
@proceedings {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 {1439,
	title = {A Comprehensive Study of Software Forks: Dates, Reasons and Outcomes},
	volume = {378},
	year = {2012},
	pages = {1-14},
	publisher = {IFIP AICT},
	abstract = {Summary. In general it is assumed that a software product evolves within the authoring company or group of developers that develop the project. However, in some cases different groups of developers make the software evolve in different directions, a situation which is commonly known as a fork. In the case of free software, although forking is a practice that is considered as a last resort, it is inherent to the four freedoms. This paper tries to shed some light on the practice of forking. Therefore, we have identified significant forks, several hundreds in total, and have studied them in depth. Among the issues that have been analyzed for each fork is the date when the forking occurred, the reason of the fork, and the outcome of the fork, i.e., if the original or the forking project are still developed. Our investigation shows, among other results, that forks occur in every software domain, that they have become more frequent in recent years, and that very few forks merge with the original project.},
	keywords = {forking, forks, free software, Legal, open source, social, software evolution, sustainability},
	attachments = {https://flosshub.org/sites/flosshub.org/files/paper_0.pdf},
	author = {Gregorio Robles and Gonz{\'a}lez-Barahona, Jes{\'u}s M.}
}
@proceedings {1458,
	title = {Do More Experienced Developers Introduce Fewer Bugs?},
	volume = {378},
	year = {2012},
	note = {"Some Mozilla Foundation projects have been the selected case of study for this paper. The analysis is based on the Mercurial repository which offers a list of repositories that can be easily cloned. As a summary, 19 projects were analyzed, with more than 100,000 commits, more than 2,500 authors and around 4 years of history up to June 2011."},
	month = {09/2012},
	pages = {268-273},
	publisher = {IFIP AICT,  Springer},
	abstract = {Developer experience is a common matter of study in the software maintenance and evolution research literature. However it is still not well understood if less experienced developers are more prone to introduce errors in the source code than their more experienced colleagues. This paper aims to study the relationships between experience and the bug introduction ratio using the Mozilla community as case of study.
As results, statistical differences among developers with different levels of experience has not been observed, when the expected result would have been the opposite1.},
	keywords = {mercurial, mozilla, scm, source code analysis},
	author = {Izquierdo-Cort{\'a}zar, Daniel and Gregorio Robles and Gonz{\'a}lez-Barahona, Jes{\'u}s M.}
}
@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}
}
@conference {1316,
	title = {An Empirical Study of Volunteer Members{\textquoteright} Perceived Turnover in Open Source Software Projects},
	booktitle = {45th Hawai{\textquoteright}i International Conference on System Sciences},
	year = {2012},
	note = {"After designing the questionnaire, we conducted a web-based survey by inviting developers working in sourceforge.net and launchpad.net."},
	month = {01/2012},
	pages = {3396-3405},
	abstract = {Turnover of volunteer members and the ensuing instability bring about severe problems to open source software (OSS) projects. To better understand it, we based our study on Herzberg ́s two-factor theory to investigate the influence of hygiene factors on volunteer members ́ dissatisfaction and perceived turnover. After empirically testing the research model, we found shortcomings in project regulation and administration are the key reason for volunteer members ́ dissatisfaction, followed by future rewards and personal needs for software functionalities. By contrast, a possible lack of supportive working relationship among OSS developers was not found to be a trigger for developer dissatisfaction. Dissatisfaction was confirmed to be a significant predictor of perceived turnover. The results demonstrates generalized hygiene factors cannot unreflectively be transferred into the OSS context because volunteer members ́ personal expectation has a weaker influence on perceived turnover than objective attributes of OSS project. Our study further makes suggestions for project administrators.},
	keywords = {developers, launchpad, sourceforge, Survey},
	author = {Yu, Yiqing and Benlian, Alexander and Hess, Thomas}
}
@article {1399,
	title = {The evolution of Java build systems},
	journal = {Empirical Software Engineering},
	volume = {17},
	year = {2012},
	month = {8/2012},
	pages = {578 - 608},
	abstract = {Build systems are responsible for transforming static source code artifacts into executable software. While build systems play such a crucial role in software development and maintenance, they have been largely ignored by software evolution researchers. However, a firm understanding of build system aging processes is needed in order to allow project managers to allocate personnel and resources to build system maintenance tasks effectively, and reduce the build maintenance overhead on regular development activities. In this paper, we study the evolution of build systems based on two popular Java build languages (i.e., ANT and Maven) from two perspectives: (1) a static perspective, where we examine the complexity of build system specifications using software metrics adopted from the source code domain; and (2) a dynamic perspective, where the complexity and coverage of representative build runs are measured. Case studies of the build systems of six open source build projects with a combined history of 172 releases show that build system and source code size are highly correlated, with source code restructurings often requiring build system restructurings. Furthermore, we find that Java build systems evolve dynamically in terms of duration and recursive depth of the directory hierarchy. },
	keywords = {ant, build, maven, scm, source code analysis},
	issn = {1573-7616},
	doi = {10.1007/s10664-011-9169-5},
	author = {McIntosh, Shane and Adams, Bram and Hassan, Ahmed E.}
}
@proceedings {1377,
	title = {Examining Turnover in Open Source Software Projects Using a Logistic Hierarchical Linear Modeling Approach},
	volume = {378},
	year = {2012},
	month = {09/2012},
	address = {Eighth International Conference on Open Source Systems},
	abstract = {Developer turnover in open source software projects is a critical and insufficiently researched problem. Previous research has focused on understanding the developer motivations to contribute using either the individual developer perspective or the project perspective. In this exploratory study we argue that because the developers are embedded in projects it is imperative to include both perspectives. We analyze turnover in open source software projects by including both individual developer level factors, as well as project specific factors. Using the Logistic Hierarchical Linear Modeling approach allows us to empirically examine the factors influencing developer turnover and also how these factors differ among developers and projects.},
	keywords = {Logistic Hierarchical Linear Modeling, sourceforge, turnover},
	author = {Sharma, P.N. and Hulland, J. and Daniel, S.}
}
@proceedings {1465,
	title = {Forking the Commons: Developmental Tensions and Evolutionary Patterns in Open Source Software},
	volume = {378},
	year = {2012},
	month = {09/2012},
	pages = {310-315},
	publisher = {IFIP AICT,  Springer},
	abstract = {Open source software (OSS) presents opportunities and challenges for developers to exploit its commons based licensing regime by creating specializations of a software technology to address plurality of goals and priorities. By {\textquoteleft}forking{\textquoteright} a new branch of development separate from the main project, development diverges into a path in order to relieve tensions related to specialization, which later encounters new tensions. In this study, we first classify forces and patterns within this divergence process. Such tensions may stem from a variety of sources including internal power conflicts, emergence of new environmental niches such as demand for specialized uses of same software, or differences along stability vs. development speed trade-off. We then present an evolutionary model which combines divergence options available to resolve tensions, and how further tensions emerge. In developing this model we attempt to define open software evolution at the level of systems of software, rather than at individual software project level.},
	keywords = {divergence, forking, software evolution, specialization},
	author = {Gen{\c c}er, Mehmet and {\"O}zel, B{\"u}lent}
}
@article {1519,
	title = {How the FLOSS Research Community Uses Email Archives},
	journal = {International Journal of Open Source Software and Processes},
	volume = {4},
	year = {2012},
	note = {classifies 72 FLOSS papers into various analysis categories},
	month = {12/2012},
	pages = {37 - 59},
	abstract = {Artifacts of the software development process, such as source code or emails between developers, are a frequent object of study in empirical software engineering literature. One of the hallmarks of free, libre, and open source software (FLOSS) projects is that the artifacts of the development process are publicly-accessible and therefore easily collected and studied. Thus, there is a long history in the FLOSS research community of using these artifacts to gain understanding about the phenomenon of open source software, which could then be compared to studies of software engineering more generally. This paper looks specifically at how the FLOSS research community has used email artifacts from free and open source projects. It provides a classification of the relevant literature using a publicly-available online repository of papers about FLOSS development using email. The outcome of this paper is to provide a broad overview for the software engineering and FLOSS research communities of how other researchers have used FLOSS email message artifacts in their work},
	keywords = {email, email archives, literature, mailing lists, review, Survey},
	issn = {1942-3934},
	doi = {10.4018/jossp.2012010103},
	attachments = {https://flosshub.org/sites/flosshub.org/files/ijossp_v3_PREPRINT.pdf},
	author = {Squire, Megan}
}
@proceedings {1457,
	title = {The Impact of Formal QA Practices on FLOSS Communities {\textendash} The Case of Mozilla},
	volume = {378},
	year = {2012},
	month = {09/2012},
	pages = {262-267},
	publisher = {IFIP AICT,  Springer},
	abstract = {The number of FLOSS projects that include a QA step in the development model is increasing which suggests that a new layer may be emerging in the classic {\textquotedblleft}onion model{\textquotedblright}. This change might affect the information flow within projects and implicitly their sustainability. Communities, the essential resource of FLOSS projects, have been extensively studied but questions concerning QA remain. This paper takes a step towards answering such questions by analyzing QA mailing lists and issue tracker data for the Mozilla group of projects. Because the Bugzilla data set contains over half a million bugs, data processing and analysis is a considerable challenge for this research. The provisional conclusions are that QA activity may not be increasing steadily over time but is dependent on other factors and that the QA team and other groups of contributors form a highly connected network that doesn{\textquoteright}t contain isolates.},
	keywords = {email, information flow, mailing lists, mozilla, quality assurance, social network analysis, test},
	author = {Barham, Adina}
}
@article {1589,
	title = {Integrating FLOSS repositories on the Web},
	year = {2012},
	note = {"To provide the researchers easy access to the project{\textquoteright}s data, two research projects were initiated (with slightly different objective)
by the FLOSS research community which are FLOSSmole and FLOSSMetrics , also known as {\textquotedblleft}repository of repositories (RoR){\textquotedblright}. These RoRs were created to consolidate metadata and analysis of projects from a variety of code forges into a centralized place for use by the researchers in academia and industry.

"In this paper, we take into consideration only project{\textquoteright}s metadata from the code forges which are
made available to download by the FLOSSmole community. Further, we only study Googlecode
and Sourceforge data for this paper, although our methods extend to other code forges as well.

Names are not available for the developers in the database dump of
Googlecode provided by FLOSSmole, so we consider matching only developer ID(s) in the case of
Googlecode."},
	month = {2012},
	abstract = {This paper provides a novel approach to the problem of integrating data from multiple code forges of FLOSS. We review the current problems in integrating the data from multiple forges and argue that Semantic Web technologies are suitable for representing knowledge contained in code forges. Further, we show the advantage of linking the metadata of projects to other data sources on the Web which will enable querying extra information from the Web. The paper briefly describes how the modeling is achieved and what benefits can be obtained by enabling linking to other relevant data sources already available on the Web.},
	keywords = {flossmole, google code, sourceforge},
	url = {https://www.researchgate.net/publication/259757473_Integrating_FLOSS_repositories_on_the_Web},
	attachments = {https://flosshub.org/sites/flosshub.org/files/DERI-TR-AFTAB-2012-12-10_0.pdf},
	author = {Iqbal, Aftab and Cyganiak, Richard and Hausenblas, Michael}
}
@book {1417,
	title = {Internet Success: A Study of Open Source Software Commons},
	year = {2012},
	note = {Supplementary material available: http://www.umass.edu/opensource/schweik/supplementary.html},
	publisher = {MIT Press},
	organization = {MIT Press},
	type = {Book},
	address = {Cambridge, MA, USA},
	keywords = {flossmole, srda},
	url = {http://tinyurl.com/d3e4545},
	author = {Schweik, C. M. and English, R.}
}
@conference {1318,
	title = {Network-Based Analysis of the Structure and Evolution of an Open Source Software Product},
	booktitle = {45th Hawai{\textquoteright}i International Conference on System Sciences},
	year = {2012},
	note = {"raw data about the product structure is extracted from the source code"},
	month = {01/2012},
	pages = {3436-3445},
	abstract = {In this paper, an analysis of product structures in open source software (OSS) at both product level and module level is presented. At the product level, the product structures are modeled as complex networks, and the evolutionary characteristics of product structures are analyzed by using network analysis metrics. At the module level, linking mechanisms, which describe how a module is attached with other modules, are proposed. The linking mechanisms are modeled as probability functions dependent on the degrees of linking modules. A case study from an open source software project, Drupal, is presented. The evolutionary trends of Drupal product structures are analyzed and discussed. Finally, a model is presented to illustrate the effects of linking mechanisms at the module level on the product structures at the system level. The results indicate that the model built using the proposed linking mechanisms generates networks whose evolutionary characteristics are close to that of the original network.},
	keywords = {drupal, source code},
	author = {Le, Qize and Panchal, Jitesh H.}
}
@proceedings {1460,
	title = {Open Source Prediction Methods: A Systematic Literature Review},
	volume = {378},
	year = {2012},
	month = {09/2012},
	pages = {280-285},
	publisher = {IFIP AICT,  Springer},
	abstract = {For the adoption of Open Source Software (OSS) components, knowledge of the project development and associated risks with their use is needed. That, in turn, calls for reliable prediction models to support preventive maintenance and building quality software. In this paper, we perform a systematic literature review on the state-of-the- art on predicting OSS projects considering both code and community dimension. We also distill future direction for research in this field.},
	keywords = {Prediction Success, Systematic literature review},
	author = {Syeed, M.M. Mahbubul and Kilamo, Terhi and Hammouda, Imed and Syst{\"a}, Tarja}
}
@proceedings {1455,
	title = {Open-Source Technologies Realizing Social Networks: A Multiple Descriptive Case-Study},
	volume = {378},
	year = {2012},
	month = {09/2012},
	pages = {250-255},
	publisher = {IFIP AICT,  Springer},
	abstract = {This article aims at describing the role of the open-source software phenomenon within high-tech corporations providing social networks and applications. By taking a multiple case study approach, We address what are the open-source software technological components embedded by leading social networking players, and a rich description on how those players collaborate with the open-source community. Our findings, based on a population of three commercial providers of social networks a suggest that open-source plays an important role on the technological development of their social networking platforms. An open-source technological stack for realizing social networks is proposed and several managerial issues dealing with collaboration with open-source communities are explored.},
	keywords = {entrepreneurship, facebook, netlog, social networks, spotify},
	author = {Teixeira, Jose}
}
@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}
}
@article {1396,
	title = {Studying the impact of social interactions on software quality},
	journal = {Empirical Software Engineering},
	year = {2012},
	note = {bug databases},
	abstract = {Correcting software defects accounts for a significant amount of resources in a software project. To make best use of testing efforts, researchers have studied statistical models to predict in which parts of a software system future defects are likely to occur. By studying the mathematical relations between predictor variables used in these models, researchers can form an increased understanding of the important connections between development activities and software quality. Predictor variables used in past top-performing models are largely based on source code-oriented metrics, such as lines of code or number of changes. However, source code is the end product of numerous interlaced and collaborative activities carried out by developers. Traces of such activities can be found in the various repositories used to manage development efforts. In this paper, we develop statistical models to study the impact of social interactions in a software project on software quality. These models use predictor variables based on social information mined from the issue tracking and version control repositories of two large open-source software projects. The results of our case studies demonstrate the impact of metrics from four different dimensions of social interaction on post-release defects. Our findings show that statistical models based on social information have a similar degree of explanatory power as traditional models. Furthermore, our results demonstrate that social information does not substitute, but rather augments traditional source code-based metrics used in defect prediction models.},
	keywords = {bug tracker, eclipse, Firefox, Human Factors, measurement, metrics, software evolution, Software quality assurance},
	issn = {1573-7616},
	doi = {10.1007/s10664-012-9205-0},
	author = {Bettenburg, Nicolas and Hassan, Ahmed E.}
}
@proceedings {1452,
	title = {Two Evolution Indicators for FOSS Projects},
	volume = {378},
	year = {2012},
	month = {09/2012},
	pages = {216-232},
	publisher = {IFIP AICT},
	abstract = {In this paper we introduce two project evolution indicators. One is showing an increase of downloads of the project and therefore a growing interest of users in the results of the project. The second indica- tor is predicting the future evolution of the project with the submission of new revisions to the concurrent versioning system. Both indicators can provide evidence of the sustainability of a software project. We used the General Linear Model method to statistically formulate the two linear equations that can be used to predict the two indicators. The predicting equations were build by using two stratified data samples one of 760 projects and the second of 880 projects extracted from the SourceForge repository. The six metrics included into the final version of the two models were extracted from a set of thirty project and product metrics as: the number of downloads, the number of developers, etc. We have validated the discriminant and the concurrent validity of the two models by using different statistical tests as the goodness-of-fit and we have used the two models to predict the indicators on two hold-out validation samples. The model predicting the increment of downloads was correct in 75 percent of the cases, the model predicting the submission of new revisions was correct in 93 percent of the cases.},
	keywords = {metrics, sourceforge},
	author = {Petrinja, Etiel and Succi, Giancarlo}
}
@conference {1319,
	title = {Who Will Remain? An Evaluation of Actual Person-Job and Person-Team Fit to Predict Developer Retention in FLOSS Projects},
	booktitle = {45th Hawai{\textquoteright}i International Conference on System Sciences},
	year = {2012},
	month = {01/2012},
	pages = {3446-3455},
	abstract = {Many businesses and private households rely on Free Libre Open Source Software (FLOSS). Due to a lack of sustained contributors, however, most FLOSS projects do not survive. The early identification of developers who are likely to remain is thus an eminent challenge for the management of FLOSS initiatives. Previous research has shown that individuals{\textquoteright} subjective assessment is often inaccurate emphasizing the need to objectively evaluate retention behavior. Consistent with the concepts Person-Job (P-J) and Person-Team (P-T) fit from the traditional recruitment literature, we derive objective measures to predict developer retention in FLOSS projects. In an analysis of the contribution behavior of former Google Summer of Code (GSoC) students we reveal that the level of development experience and conversational knowledge is strongly associated with retention. Surprisingly, our analysis reveals that students with abilities that are underrepresented in the project and students with a higher academic education do not remain considerably longer.},
	keywords = {email, email archives, google summer of code, kde, mailing list, students},
	doi = {http://doi.ieeecomputersociety.org/10.1109/HICSS.2012.644},
	attachments = {https://flosshub.org/sites/flosshub.org/files/45.pdf},
	author = {Schilling, A. and Laumer, S. and Weitzel, T.}
}
@proceedings {1285,
	title = {Adoption of OSS Development Practices by the Software Industry: A Survey},
	year = {2011},
	month = {10/2011},
	pages = {233-243},
	publisher = {Springer},
	abstract = {The paper presents a survey of aspects related to the adoption of Open Source Software by the software industry. The aim of this study was to collect data related to practices and elements in the development process of companies that influence the trust in the quality of the product by potential adopters. The work is part of the research done inside the QualiPSo project and was carried out using a qualitative study based on a structured questionnaire focused on perceptions of experts and development practices used by companies involved in the Open Source Software industry. The results of the survey confirm intuitive concerns related to the adoption of Open Source Software as: the selection of the license, the quality issues addressed, and the development process tasks inside Open Source Software projects. The study uncovered specific aspects related to trust and trustworthiness of the Open Source Software development process that we did not find in previous studies as: the standards implemented by the OSS project, the project{\textquoteright}s roadmap is respected, and the communication channels that are available.},
	keywords = {qualipso, Survey},
	author = {Petrinja, Etiel and Sillitti, Alberto and Succi, Giancarlo}
}
@conference {1314,
	title = {Apples vs. oranges?},
	booktitle = {Proceedings of the 8th working conference on Mining software repositories - MSR {\textquoteright}11},
	year = {2011},
	note = {"In this MSR challenge report, we compare the source code of two in- dustrial grade Integrated Development Environments (IDE): Netbeans, developed by Oracle Corporation, and Eclipse, developed by the Eclipse Foundation. In the same spirit as [1], our goal is not to identify how similar or different they are, but to identify differences that, if not taken into consideration, might result in biased, and potentially erroneous conclusions."},
	month = {05/2011},
	pages = {246-249},
	publisher = {ACM Press},
	organization = {ACM Press},
	address = {New York, New York, USA},
	abstract = {We attempt to compare the source code of two Java IDE systems: Netbeans and Eclipse. The result of this experiment shows that many factors, if ignored, could risk a bias in the results, and we posit various observations that should be taken into consideration to minimize such risk.

},
	keywords = {eclipse, netbeans, source code},
	isbn = {9781450305747},
	doi = {10.1145/1985441.1985483},
	author = {Davies, Julius and Daniel M. German}
}
@article {1324,
	title = {Are Developers Fixing Their Own Bugs?},
	journal = {International Journal of Open Source Software and Processes},
	volume = {3},
	year = {2011},
	note = {"The analysis is focused at the level of lines of code and it uses the information stored in the source code management system"},
	pages = {23 - 42},
	abstract = {The process of fixing software bugs plays a key role in the maintenance activities of a software project. Ideally, code ownership and responsibility should be enforced among developers working on the same artifacts, so that those introducing buggy code could also contribute to its fix. However, especially in FLOSS projects, this mechanism is not clearly understood: in particular, it is not known whether those contributors fixing a bug are the same introducing and seeding it in the first place. This paper analyzes the comm-central FLOSS project, which hosts part of the Thunderbird, SeaMonkey, Lightning extensions and Sunbird projects from the Mozilla community. The analysis is focused at the level of lines of code and it uses the information stored in the source code management system. The results of this study show that in 80\% of the cases, the bug-fixing activity involves source code modified by at most two developers. It also emerges that the developers fixing the bug are only responsible for 3.5\% of the previous modifications to the lines affected; this implies that the other developers making changes to those lines could have made that fix. In most of the cases the bug fixing process in comm-central is not carried out by the same developers than those who seeded the buggy code.},
	keywords = {bug fixing, developers, loc, scm},
	issn = {1942-3934},
	doi = {10.4018/jossp.2011040102},
	author = {Izquierdo-Cortazar, Daniel and Capiluppi, Andrea and Jesus M. Gonzalez-Barahona}
}
@proceedings {1295,
	title = {Aspects of an Open Source Software Sustainable Life Cycle},
	year = {2011},
	month = {10/2011},
	pages = {325-329},
	publisher = {Springer},
	abstract = {In this paper we present a literature overview about OSS sustainability, considering not only financial resources, but also community growth, source code and tools management. Based on these aspects, we define an OSS life cycle that may contribute to OSS projects sustainability.},
	keywords = {Financial Resources, OSS Communities, OSS Sustainability, software maintenance},
	author = {Arantes, Flavia Linhalis and Freire, Fernanda Maria Pereira}
}
@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.}
}
@article {1320,
	title = {An Empirical Study of Open Source Software Usability},
	journal = {International Journal of Open Source Software and Processes},
	volume = {3},
	year = {2011},
	pages = {1 - 16},
	abstract = {Recent years have seen a sharp increase in the use of open source projects by common novice users; Open Source Software (OSS) is thus no longer a reserved arena for software developers and computer gurus. Although user-centered designs are gaining popularity in OSS, usability is still not considered one of the prime objectives in many design scenarios. This paper analyzes industry users{\textquoteright} perception of usability factors, including understandability, learnability, operability, and attractiveness on OSS usability. The research model of this empirical study establishes the relationship between the key usability factors and OSS usability from industrial perspective. In order to conduct the study, a data set of 105 industry users is included. The results of the empirical investigation indicate the significance of the key factors for OSS usability.},
	keywords = {Survey},
	issn = {1942-3934},
	doi = {10.4018/jossp.2011010101},
	author = {Raza, Arif and Capretz, Luiz Fernando and Ahmed, Faheem}
}
@proceedings {1283,
	title = {Framing the Conundrum of Total Cost of Ownership of Open Source Software},
	year = {2011},
	month = {10/2011},
	pages = {208-219},
	publisher = {Springer},
	abstract = {This paper reflects the results of phase I of our study on the total cost of ownership (TCO) of open source software adoption. Not only have we found TCO to be an intriguing issue but it is contentious, baffling and each company approaches it in a distinctive manner (and sometimes not at all). In effect it is a conundrum that needs unpacking before it can be explained and understood. Our paper discusses the components of TCO as total cost of ownership and total cost of acquisition (and besides). Using this broad dichotomy and its various components we then analyze our data to make sense of procurement decisions in relation to open source software in the public sector and private companies.},
	keywords = {benefits, exit costs, open source software, software adoption, Survey, tco, total cost of ownership},
	author = {Maha Shaikh and Cornford, Tony}
}
@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 {1306,
	title = {Java generics adoption},
	booktitle = {Proceedings of the 8th working conference on Mining software repositories - MSR {\textquoteright}11},
	year = {2011},
	note = {"we automatically analyzed 20 open source software projects. We analyzed the top {\textquotedblleft}most used{\textquotedblright} projects according to ohloh.net, including only projects with significant amounts of Java code"

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

"In mining the full version histories of these 20 projects, we analyzed the full content of each version of each Java source file, a total of 548,982,841 lines."},
	month = {05/2011},
	pages = {3-12},
	publisher = {ACM Press},
	organization = {ACM Press},
	address = {New York, New York, USA},
	abstract = {Support for generic programming was added to the Java language in 2004, representing perhaps the most significant change to one of the most widely used programming languages today. Researchers and language designers anticipated this addition would relieve many long-standing problems plaguing developers, but surprisingly, no one has yet measured whether generics actually provide such relief. In this paper, we report on the first empirical investigation into how Java generics have been integrated into open source software by automatically mining the history of 20 popular open source Java programs, traversing more than 500 million lines of code in the process. We evaluate five hypotheses, each based on assertions made by prior researchers, about how Java developers use generics. For example, our results suggest that generics do not significantly reduce the number of type casts and that generics are usually adopted by a single champion in a project, rather than all committers.},
	keywords = {commits, generics, java, source code, version history},
	isbn = {9781450305747},
	doi = {10.1145/1985441.1985446},
	author = {Christian Bird and Murphy-Hill, Emerson and Parnin, Chris}
}
@conference {1481,
	title = {Joining Free/Open Source Software Communities: An Analysis of Newbies{\textquoteright} First Interactions on Project Mailing Lists},
	booktitle = {2011 44th Hawaii International Conference on System Sciences (HICSS 2011)},
	year = {2011},
	pages = {1 - 10},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Kauai, HI},
	abstract = {Free/Open source software (FOSS) is an important part of the IT ecosystem. Due to the voluntary nature of participation, continual recruitment is key to the growth and sustainability of these communities. It is therefore important to understand how and why potential contributors fail in the process of transitioning from user to contributor. Most newcomers, or "newbies", have their first interaction with a community through a mailing list. To understand how this first contact influences future interactions, we studied eight mailing lists across four FOSS projects: MediaWiki, GIMP, PostgreSQL, and Subversion. We analyzed discussions initiated by newbies to determine the effect of gender, nationality, politeness, helpfulness and timeliness of response. We found that nearly 80\% of newbie posts received replies, and that receiving timely responses, especially within 48 hours, was positively correlated with future participation. We also found that while the majority of interactions were positive, 1.5\% of responses were rude or hostile.},
	keywords = {email, email archive, gimp, mailing list, mediawiki, postgresql, subversion},
	isbn = {978-1-4244-9618-1},
	doi = {10.1109/HICSS.2011.264},
	author = {Jensen, Carlos and King, Scott and Kuechler, Victor}
}
@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 {1284,
	title = {Libre Software as an Innovation Enabler in India: Experiences of a Bangalorian Software SME},
	year = {2011},
	month = {10/2011},
	pages = {220-232},
	publisher = {Springer},
	abstract = {Free/Libre and open source software (FLOSS) has been advocated for its presumed capacity to support native software industries in developing countries. It is said to create new spaces for exploration and to lower entry barriers to mature software markets, for example. However, little empirical research has been conducted concerning FLOSS business in a developing country setting and, thus, there is not much evidence to support or refute these claims. This paper presents a business case study conducted in India, a country branded as a {\textquoteright}software powerhouse{\textquoteright} of the developing world. The findings show how FLOSS has opened up significant opportunities for the case company, especially in terms of improving its innovative capability and upgrading in the software value chain. On the other hand, they also highlight some challenges to FLOSS involvement that rise specifically from the Indian context.},
	keywords = {free software, India, INNOVATION, open source, software business},
	author = {Henttonen, Katja}
}
@proceedings {1275,
	title = {Preparing FLOSS for Future Network Paradigms: A Survey on Linux Network Management},
	year = {2011},
	month = {10/2011},
	pages = {75-89},
	publisher = {Springer},
	abstract = {Operating system tools must fulfill the requirements generated by the advances in networking paradigms. To understand the current state of the Free, Libre and Open Source Software (FLOSS) ecosystem, we present a survey on the main tools used to manage and interact with the network, and how they are organized in Linux-based operating systems. Based on the survey results, we present a reference Linux network stack that can serve as the basis for future heterogeneous network environments, contributing towards a standardized approach in Linux. Using this stack, and focusing on dynamic and spontaneous network interactions, we present an evolution path for network related technologies, contributing to Linux as a network research operating system and to FLOSS as a whole.},
	keywords = {linux, networking, Survey},
	author = {Matos, Alfredo and Thomson, John and Paulo Trezentos}
}
@conference {1406,
	title = {Process Mining Software Repositories},
	booktitle = {15th European Conference on Software Maintenance and Reengineering (CSMR 2011) },
	year = {2011},
	pages = {5 - 14},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Oldenburg, Germany},
	abstract = {Software developers{\textquoteright} activities are in general recorded in software repositories such as version control systems, bug trackers and mail archives. While abundant information is usually present in such repositories, successful information extraction is often challenged by the necessity to simultaneously analyze different repositories and to combine the information obtained.

We propose to apply process mining techniques, originally developed for business process analysis, to address this challenge. However, in order for process mining to become applicable, different software repositories should be combined, and {\textquotedblleft}related{\textquotedblright} software development events should be matched: e.g., mails sent about a file, modifications of the file and bug reports that can be traced back to it.

The combination and matching of events has been implemented in FRASR (FRamework for Analyzing Software Repositories), augmenting the process mining framework ProM. FRASR has been successfully applied in a series of case studies addressing such aspects of the development process as roles of different developers and the way bug reports are handled.},
	keywords = {amsn, email, email archives, gcc, mailing list, Process mining, software repositories},
	isbn = {978-1-61284-259-2},
	doi = {10.1109/CSMR.2011.5},
	attachments = {https://flosshub.org/sites/flosshub.org/files/2011-03_CSMR.pdf},
	author = {Poncin, Wouter and Serebrenik, Alexander and Brand, Mark van den}
}
@article {1386,
	title = {Sociomaterial bricolage: The creation of location-spanning work practices by global software developers},
	journal = {Information and Software Technology},
	volume = {53},
	year = {2011},
	month = {9/2011},
	pages = {955 - 968},
	abstract = {Context

Studies on global software development have documented severe coordination and communication problems among coworkers due to geographic dispersion and consequent dependency on technology. These problems are exacerbated by increase in the complexity of work undertaken by global teams. However, despite these problems, global software development is on the rise and firms are adopting global practices across the board, raising the question: What does successful global software development look like and what can we learn from its practitioners?
Objective

This study draws on practice-based studies of work to examine successful work practices of global software developers. The primary aim of this study was to understand how workers develop practices that allow them to function effectively across geographically dispersed locations.
Method

An ethnographically-informed field study was conducted with data collection at two international locations of a firm. Interview, observation and archival data were collected. A total of 42 interviews and 3 weeks of observations were conducted.
Results

Teams spread across different locations around the world developed work practices through sociomaterial bricolage. Two facets of technology use were necessary for the creation of these practices: multiplicity of media and relational personalization at dyadic and team levels. New practices were triggered by the need to achieve a work-life balance, which was disturbed by global development. Reflecting on my role as a researcher, I underscore the importance of understanding researchers{\textquoteright} own frames of reference and using research practices that mirror informants{\textquoteright} work practices.
Conclusion

Software developers on global teams face unique challenges which necessitate a shift in their work practices. Successful teams are able to create practices that span locations while still being tied to location based practices. Inventive use of material and social resources is central to the creation of these practices.},
	keywords = {Global software development, Interpretive analysis, interviews, Qualitative field study, Sociomaterial bricolage, Virtual teams, Work practices},
	issn = {09505849},
	doi = {10.1016/j.infsof.2011.01.014},
	url = {http://www.sciencedirect.com/science/article/pii/S0950584911000437},
	author = {Johri, Aditya}
}
@conference {Meneely:2011:SDN:1985793.1985832,
	title = {Socio-technical developer networks: should we trust our measurements?},
	booktitle = {Proceedings of the 33rd International Conference on Software Engineering},
	series = {ICSE {\textquoteright}11},
	year = {2011},
	pages = {281{\textendash}290},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {Software development teams must be properly structured to provide effectiv collaboration to produce quality software. Over the last several years, social network analysis (SNA) has emerged as a popular method for studying the collaboration and organization of people working in large software development teams. Researchers have been modeling networks of developers based on socio-technical connections found in software development artifacts. Using these developer networks, researchers have proposed several SNA metrics that can predict software quality factors and describe the team structure. But do SNA metrics measure what they purport to measure? The objective of this research is to investigate if SNA metrics represent socio-technical relationships by examining if developer networks can be corroborated with developer perceptions. To measure developer perceptions, we developed an online survey that is personalized to each developer of a development team based on that developer{\textquoteright}s SNA metrics. Developers answered questions about other members of the team, such as identifying their collaborators and the project experts. A total of 124 developers responded to our survey from three popular open source projects: the Linux kernel, the PHP programming language, and the Wireshark network protocol analyzer. Our results indicate that connections in the developer network are statistically associated with the collaborators whom the developers named. Our results substantiate that SNA metrics represent socio-technical relationships in open source development projects, while also clarifying how the developer network can be interpreted by researchers and practitioners.},
	keywords = {developer network, developers, linux, linux kernel, PHP, social network analysis, Survey, wireshark},
	isbn = {978-1-4503-0445-0},
	doi = {10.1145/1985793.1985832},
	url = {http://doi.acm.org/10.1145/1985793.1985832},
	author = {Meneely, Andrew and Williams, Laurie}
}
@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 {Stroulia:2011:TDS:1984665.1984670,
	title = {Teaching distributed software engineering with UCOSP: the undergraduate capstone open-source project},
	booktitle = {Proceedings of the 2011 Community Building Workshop on Collaborative Teaching of Globally Distributed Software Development},
	series = {CTGDSD {\textquoteright}11},
	year = {2011},
	pages = {20{\textendash}25},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {Software engineering courses in computer-science departments are meant to prepare students for the practice of designing, developing, understanding and maintaining software in the real world. The effectiveness of these courses have potentially a tremendous impact on the software industry, since it is through these courses that students must learn the state-of-the-art process and the tools of their eventual "trade", so that they can bring this knowledge to their job and thus advance the actual state of practice. The value of "learning software engineering" through project-based courses has long been recognized by educators and practitioners alike. In this paper, we discuss our experience with a distributed project-based course, which infuses the students{\textquoteright} learning experience with an increased degree of realism, which, we believe, further improves the quality of their learning and advances their readiness to join the profession.},
	keywords = {distributed, education, pedagogical, project-based courses, software engineering education},
	isbn = {978-1-4503-0590-7},
	doi = {10.1145/1984665.1984670},
	url = {http://doi.acm.org/10.1145/1984665.1984670},
	author = {Stroulia, Eleni and Bauer, Ken and Craig, Michelle and Reid, Karen and Wilson, Greg}
}
@proceedings {1287,
	title = {To Fork or Not to Fork: Fork Motivations in SourceForge Projects},
	year = {2011},
	note = {"Using this search function, we compiled a list of all of the programs with the word {\textquotedblleft}fork{\textquotedblright}..."
"We then analyzed the motivations stated in the descriptions of the forked programs...."
"Based on the descriptions entered by the developer, we were able to identify motivations for 381 of the forks."
},
	month = {10/2011},
	pages = {259-268},
	publisher = {Springer},
	abstract = {A project fork occurs when software developers take a copy of source code from one software package and use it to begin an independent development work that is maintained separately from its origin. Although forking in open source software does not require the permission of the original authors, the new version, nevertheless, competes for the attention of the same developers that have worked on the original version. The motivations developers have for performing forks are many, but in general they have received little attention. In this paper, we present the results of a study of forks performed in SourceForge (http://sourceforge.net/) and list the developers{\textquoteright} motivations for their actions. The main motivation, seen in close to half of the cases of forking, was content modification; either adding content to the original program or focusing the content to the needs of a specific segment of users. In a quarter of the cases the motivation was technical modification; either porting the program to new hardware or software, or improving the original.},
	keywords = {fork rate, sourceforge},
	author = {Nyman, Linus and Mikkonen, Tommi}
}
@proceedings {1271,
	title = {Towards a Unified Definition of Open Source Quality},
	year = {2011},
	note = {"In order to answer the research question, how is quality defined in the FLOSS literature, we performed a literature review."

"we searched Google Scholar for journal articles and conference papers containing the terms {\textquotedblleft}open source{\textquotedblright} and {\textquotedblleft}quality{\textquotedblright}"

"This process left us with 24 papers, to which we then added 16 from the quality and defect-fixing categories in [34] that met the above stated criteria.
This left us with 40 papers that defined quality and performed some form of empirical validation of that definition."

"there is little consensus in the FLOSS literature when it comes to defining quality."

defect resolution versus modularity: "Defect resolution rates (amount of defects resolved, speed of resolution) are the best way to measure a community{\textquoteright}s commitment to quality, because they recognize that FLOSS is not a static product, but ever evolving. These rates should be calculated per release, and not cumulatively, because the cycle of FLOSS evolution is the release. Researchers should be careful to only include defects and not new feature requests, duplicates, or poorly reported bugs into their calculations.
Modularity is being touted as the main driver of FLOSS quality success, but it needs to be further defined and studied in order to understand how it works."},
	month = {10/2011},
	pages = {17-33},
	publisher = {Springer},
	abstract = {Software quality needs to be specified and evaluated in order to determine the success of a development project, but this is a challenge with Free/Libre Open Source Software (FLOSS) because of its permanently emergent state. This has not deterred the growth of the assumption that FLOSS is higher quality than traditionally developed software, despite of mixed research results. With this literature review, we found the reason for these mixed results is that that quality is being defined, measured, and evaluated differently. We report the most popular definitions, such as software structure measures, process measures, such as defect fixing, and maturity assessment models. The way researchers have built their samples has also contributed to the mixed results with different project properties being considered and ignored. Because FLOSS projects are evolving, their quality is too, and it must be measured using metrics that take into account its community{\textquoteright}s commitment to quality rather than just its software structure. Challenges exist in defining what constitutes a defect or bug, and the role of modularity in affecting FLOSS quality.},
	keywords = {literature review, measurement, open source, quality, Software},
	author = {Ruiz, Claudia and Robinson, William}
}
@proceedings {1286,
	title = {Towards Improving OSS Products Selection {\textendash} Matching Selectors and OSS Communities Perspectives},
	year = {2011},
	month = {10/2011},
	pages = {244-258},
	publisher = {Springer},
	abstract = {Adopting third-party software is becoming an economical and strategic need for today organizations. A fundamental part of its successful adoption is the informed selection of products that best fit the organization needs. One of the main current problems hampering selection, specially of OSS products is the vast amount of unstructured, incomplete, evolvable and widespread information about products that highly increases the risks of taking a wrong decision. In this paper, we aim to inform and provide evidence to OSS communities that help them to envisage improvements on their information rendering strategies to satisfy industrial OSS selectors{\textquoteright} needs. Our results are from the matching between the informational needs of 23 OSS selectors from diverse software-intensive organizations, and the in-depth study of 9 OSS communities of different sizes and domains. The results evidenced specific areas of improvement that might help to enhance the industrial OSS selection practice.},
	keywords = {empirical study, information rendering strategy, open source software, selection},
	author = {Ayala, Claudia and Cruzes, Daniela S. and Franch, Xavier and Conradi, Reidar}
}
@conference {Bougie:2011:TUT:1984701.1984707,
	title = {Towards understanding twitter use in software engineering: preliminary findings, ongoing challenges and future questions},
	booktitle = {Proceedings of the 2nd International Workshop on Web 2.0 for Software Engineering},
	series = {Web2SE {\textquoteright}11},
	year = {2011},
	note = {paper d/l from http://www.thechiselgroup.org/publications/content/towards-understanding-twitter-use-software-engineering-preliminary-findings-ong

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

"From this site, we selected the top 30 individuals for the topics Linux and Eclipse. We chose these two topics based on their potential to expose "tweeters" from a large operating system community as well as an IDE development community. We also decided to investigate a project for which all committers use Twitter. Through a colleague, we were informed that the MXUnit project lists the Twitter user names for all eight of its committers. The MXUnit project [5] is a small, open source ColdFusion test framework that is written as an Eclipse plug-in."},
	pages = {31{\textendash}36},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {There has been some research conducted around the motivation for the use of Twitter and the value brought by micro-blogging tools to individuals and business environments. This paper builds on our understanding of how the phenomenon affects the population which birthed the technology: Software Engineers. We find that the Software Engineering community extensively leverages Twitter{\textquoteright}s capabilities for conversation and information sharing and that use of the tool is notably different between distinct Software Engineering groups. Our work exposes topics for future research and outlines some of the challenges in exploring this type of data.},
	keywords = {eclipse, linux, mxunit, social media, software development, twitter, web 2.0},
	isbn = {978-1-4503-0595-2},
	doi = {10.1145/1984701.1984707},
	url = {http://doi.acm.org/10.1145/1984701.1984707},
	attachments = {https://flosshub.org/sites/flosshub.org/files/WEB2SE2011_0.pdf},
	author = {Bougie, Gargi and Starke, Jamie and Storey, Margaret-Anne and Daniel M. German}
}
@conference {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}
}
@article {howison2010validity-issues,
	title = {Validity Issues in the Use of Social Network Analysis with Digital Trace data},
	journal = {Journal of the Association for Information Systems},
	volume = {12},
	year = {2011},
	chapter = {Article 2},
	abstract = {There is an exciting natural match between social network analysis methods and the growth of data sources produced by social interactions via information technologies, from online communities to corporate information systems. Information Systems researchers have not been slow to embrace this combination of method and data. Such systems increasingly provide "digital trace data" that provide new research opportunities. Yet digital trace data are substantively different from the survey and interview data for which network analysis measures and interpretations were originally developed. This paper examines ten validity issues associated with the combination of data digital trace data and social network analysis methods, with examples from the IS literature, to provide recommendations for improving the validity of research using this combination.},
	keywords = {information system, Online Communities, social network analysis, Virtuality},
	attachments = {https://flosshub.org/sites/flosshub.org/files/HowisonSNADigitalTraceData-WorkingPaper.pdf},
	author = {Howison, James and Andrea Wiggins and Kevin Crowston}
}
@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}
}
@article {1388,
	title = {Adoption of open source software in software-intensive organizations {\textendash} A systematic literature review},
	journal = {Information and Software Technology},
	volume = {52},
	year = {2010},
	month = {11/2010},
	pages = {1133 - 1154},
	abstract = {Context

Open source software (OSS) is changing the way organizations develop, acquire, use, and commercialize software.
Objective

This paper seeks to identify how organizations adopt OSS, classify the literature according to these ways of adopting OSS, and with a focus on software development evaluate the research on adoption of OSS in organizations.
Method

Based on the systematic literature review method we reviewed publications from 24 journals and seven conference and workshop proceedings, published between 1998 and 2008. From a population of 24,289 papers, we identified 112 papers that provide empirical evidence on how organizations actually adopt OSS.
Results

We show that adopting OSS involves more than simply using OSS products. We moreover provide a classification framework consisting of six distinctly different ways in which organizations adopt OSS. This framework is used to illustrate some of the opportunities and challenges organizations meet when approaching OSS, to show that OSS can be adopted successfully in different ways, and to organize and review existing research. We find that existing research on OSS adoption does not sufficiently describe the context of the organizations studied, and it fails to benefit fully from related research fields. While existing research covers a large number of topics, it contains very few closely related studies. To aid this situation, we offer directions for future research.
Conclusion

The implications of our findings are twofold. On the one hand, practitioners should embrace the many opportunities OSS offers, but consciously evaluate the consequences of adopting it in their own context. They may use our framework and the success stories provided by the literature in their own evaluations. On the other hand, researchers should align their work, and perform more empirical research on topics that are important to organizations. Our framework may be used to position this research and to describe the context of the organization they are studying.},
	keywords = {open source software, organizations, software development, Systematic literature review},
	issn = {09505849},
	doi = {10.1016/j.infsof.2010.05.008},
	url = {http://www.sciencedirect.com/science/article/pii/S0950584910000972},
	author = {Hauge, {\O}yvind and Ayala, Claudia and Conradi, Reidar}
}
@article {1382,
	title = {Analysis of virtual communities supporting OSS projects using social network analysis},
	journal = {Information and Software Technology},
	volume = {52},
	year = {2010},
	month = {3/2010},
	pages = {296 - 303},
	abstract = {This paper analyses the behaviour of virtual communities for Open Source Software (OSS) projects. The development of OSS projects relies on virtual communities, which are built on relationships among members, being their final objective sharing knowledge and improving the underlying project. This study addresses the interactive collaboration in these kinds of communities applying social network analysis (SNA). In particular, SNA techniques will be used to identify those members playing a middle-man role among other community members. Results will illustrate the importance of this role to achieve successful virtual communities.},
	keywords = {arm, email, Knowledge brokers, linux, mailing list, open source software, social network analysis, virtual communities},
	issn = {09505849},
	doi = {10.1016/j.infsof.2009.10.007},
	url = {http://www.sciencedirect.com/science/article/pii/S0950584909001888},
	author = {Toral, S.L. and Mart{\'\i}nez-Torres, M.R. and Barrero, F.}
}
@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 {963,
	title = {Automated dependency resolution for open source software},
	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 = {130 - 140},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Cape Town, South Africa},
	abstract = {Opportunities for software reuse are plentiful, thanks in large part to the widespread adoption of open source processes and the availability of search engines for locating relevant artifacts. One challenge presented by open source software reuse is simply getting a newly downloaded artifact to build/run in the first place. The artifact itself likely reuses other artifacts, and so depends on their being located to function properly. While merely tedious in the individual case, this can cause serious difficulties for those seeking to study open source software. It is simply not feasible to manually resolve dependencies for thousands of projects, and many forms of analysis require declarative completeness. In this paper we present a method for automatically resolving dependencies for open source software. It works by cross-referencing a project{\textquoteright}s missing type information with a repository of candidate artifacts. We have implemented this method on top of the Sourcerer, an infrastructure for the large-scale indexing and analysis of open source code. The performance of our resolution algorithm was evaluated in two parts. First, for a small number of popular open source projects, we manually examined the artifacts suggested by our system to determine if they were appropriate. Second, we applied the algorithm to the 13,241 projects in the Sourcerer managed repository to evaluate the rate of resolution success. The results demonstrate the feasibility of this approach, as the algorithm located all of the required artifacts needed by 3,904 additional projects, increasing the percentage of declaratively complete projects in Sourcerer from 39\% to 69\%.},
	keywords = {dependencies, java, source code, sourcerer},
	isbn = {978-1-4244-6802-7},
	doi = {10.1109/MSR.2010.5463346},
	author = {Ossher, Joel and Bajracharya, Sushil and Lopes, Cristina}
}
@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}
}
@article {1330,
	title = {Data Mining User Activity in Free and Open Source Software (FOSS)/ Open Learning Management Systems},
	journal = {International Journal of Open Source Software and Processes},
	volume = {2},
	year = {2010},
	pages = {65 - 75},
	abstract = {Free and Open Source Software (FOSS)/Open Educational Systems development projects abound in higher education today. Many universities worldwide have adopted open source software like ATutor and Moodle as an alternative to commercial or homegrown systems. The move to open source learning management systems entails many special considerations, including usage analysis facilities. The tracking of users and their activities poses major technical and analytical challenges within web-based systems. This paper examines how user activity tracking challenges are met with data mining techniques, particularly web usage mining methods, in four different open learning management systems: ATutor, LON-CAPA, Moodle, and Sakai. As examples of data mining technologies adapted within widely used systems, they represent important first steps for moving educational data mining outside the research laboratory. Moreover, as examples of different open source development contexts, exemplify the potential for programmatic integration of data mining technology processes in the future. As open systems mature in the use of educational data mining, they move closer to the long-sought goal of achieving more interactive, personalized, adaptive learning environments online on a broad scale.},
	keywords = {data mining, education, student},
	issn = {1942-3934},
	doi = {10.4018/jossp.2010010105},
	author = {McGrath, Owen}
}
@article {1328,
	title = {Developing a Dynamic and Responsive Online Learning Environment},
	journal = {International Journal of Open Source Software and Processes},
	volume = {2},
	year = {2010},
	pages = {32 - 48},
	abstract = {Charles Stuart University adopted the open source software, Sakai, as the foundation for the university{\textquoteright}s new, integrated Online Learning Environment. This study explores whether a pedagogical advantage exists in adopting such an open source learning management system. Research suggests that the community source approach to development of open source software has many inherent pedagogical advantages, but this paper examines whether this is due to the choice of open source software or simply having access to appropriate technology for learning and teaching in the 21st century. The author also addresses the challenges of the project management methodology and processes in the large-scale implementation of an open-source courseware management solution at the institutional level. Consequently, this study outlines strategies that an institution can use to harness the potential of a community source approach to software development to meet the institutional and individual user needs into the future. },
	keywords = {education, learning, sakai},
	issn = {1942-3934},
	doi = {10.4018/jossp.2010010103},
	author = {Buchan, Janet}
}
@conference {961,
	title = {Do stack traces help developers fix bugs?},
	booktitle = {2010 7th IEEE Working Conference on Mining Software Repositories (MSR 2010)2010 7th IEEE Working Conference on Mining Software Repositories (MSR 2010)},
	year = {2010},
	pages = {118 - 121},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Cape Town, South Africa},
	abstract = {A widely shared belief in the software engineering community is that stack traces are much sought after by developers to support them in debugging. But limited empirical evidence is available to confirm the value of stack traces to developers. In this paper, we seek to provide such evidence by conducting an empirical study on the usage of stack traces by developers from the ECLIPSE project. Our results provide strong evidence to this effect and also throws light on some of the patterns in bug fixing using stack traces. We expect the findings of our study to further emphasize the importance of adding stack traces to bug reports and that in the future, software vendors will provide more support in their products to help general users make such information available when filing bug reports.},
	keywords = {bug fixing, bug report, debugging, eclipse, stack trace},
	isbn = {978-1-4244-6802-7},
	doi = {10.1109/MSR.2010.5463280},
	attachments = {https://flosshub.org/sites/flosshub.org/files/118-10-msr.pdf},
	author = {Schroter, Adrian and Schr{\"o}ter, Adrian and Bettenburg, Nicolas and Premraj, Rahul}
}
@inbook {springerlink:10.1007/978-3-642-13244-5_20,
	title = {Download Patterns and Releases in Open Source Software Projects: A Perfect Symbiosis?},
	booktitle = {Open Source Software: New Horizons},
	series = {IFIP Advances in Information and Communication Technology},
	volume = {319},
	year = {2010},
	note = {"We apply experimentally our method to the most downloaded projects of SourceForge{\textquoteright}s history crawled through the FLOSSMole repository."},
	pages = {252-267},
	publisher = {Springer Boston},
	organization = {Springer Boston},
	abstract = {Software usage by end-users is one of the factors used to evaluate the success of software projects. In the context of open source software, there is no single and non-controversial measure of usage, though. Still, one of the most used and readily available measure is data about projects downloads. Nevertheless, download counts and averages do not convey as much information as the patterns in the original downloads time series. In this research, we propose a method to increase the expressiveness of mere download rates by considering download patterns against software releases. We apply experimentally our method to the most downloaded projects of SourceForge{\textquoteright}s history crawled through the FLOSSMole repository. Findings show that projects with similar usage can have indeed different levels of sensitivity to releases, revealing different behaviors of users. Future research will develop further the pattern recognition approach to automatically categorize open source projects according to their download patterns.},
	keywords = {flossmole, oss2010, sourceforge},
	url = {http://dx.doi.org/10.1007/978-3-642-13244-5_20},
	author = {Rossi, Bruno and Russo, Barbara and Succi, Giancarlo},
	editor = {{\r A}gerfalk, P{\"a}r and Boldyreff, Cornelia and Gonz{\'a}lez-Barahona, Jes{\'u}s and Madey, Gregory and Noll, John}
}
@conference {951,
	title = {The evolution of ANT build systems},
	booktitle = {2010 7th IEEE Working Conference on Mining Software Repositories (MSR 2010)2010 7th IEEE Working Conference on Mining Software Repositories (MSR 2010)},
	year = {2010},
	pages = {42 - 51},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Cape Town, South Africa},
	abstract = {Build systems are responsible for transforming static source code artifacts into executable software. While build systems play such a crucial role in software development and maintenance, they have been largely ignored by software evolution researchers. With a firm understanding of build system aging processes, project managers could allocate personnel and resources to build system maintenance tasks more effectively, reducing the build maintenance overhead on regular development activities. In this paper, we study the evolution of ANT build systems from two perspectives: (1) a static perspective, where we examine the build system specifications using software metrics adopted from the source code domain; and (2) a dynamic perspective where representative sample build runs are conducted and their output logs are analyzed. Case studies of four open source ANT build systems with a combined history of 152 releases show that not only do ANT build systems evolve, but also that they need to react in an agile manner to changes in the source code.},
	keywords = {ant, argouml, build, eclipse, jboss, maintenance, metrics, source code, tomcat},
	isbn = {978-1-4244-6802-7},
	doi = {10.1109/MSR.2010.5463341},
	attachments = {https://flosshub.org/sites/flosshub.org/files/42msr2010_mcintosh.pdf},
	author = {McIntosh, Shane and Adams, Bram and Hassan, Ahmed E.}
}
@conference {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 {950,
	title = {An extensive comparison of bug prediction approaches},
	booktitle = {2010 7th IEEE Working Conference on Mining Software Repositories (MSR 2010)2010 7th IEEE Working Conference on Mining Software Repositories (MSR 2010)},
	year = {2010},
	pages = {31 - 41},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Cape Town, South Africa},
	abstract = {Reliably predicting software defects is one of software engineering{\textquoteright}s holy grails. Researchers have devised and implemented a plethora of bug prediction approaches varying in terms of accuracy, complexity and the input data they require. However, the absence of an established benchmark makes it hard, if not impossible, to compare approaches. We present a benchmark for defect prediction, in the form of a publicly available data set consisting of several software systems, and provide an extensive comparison of the explanative and predictive power of well-known bug prediction approaches, together with novel approaches we devised. Based on the results, we discuss the performance and stability of the approaches with respect to our benchmark and deduce a number of insights on bug prediction models.},
	keywords = {apache, bug reports, eclipse, famix, lucene, mylyn, prediction, scm},
	isbn = {978-1-4244-6802-7},
	doi = {10.1109/MSR.2010.5463279},
	attachments = {https://flosshub.org/sites/flosshub.org/files/31dambrosLanzaRobbes31.pdf},
	author = {D{\textquoteright}Ambros, Marco and Lanza, Michele and Robbes, Romain}
}
@conference {1358,
	title = {Extracting source code from e-mails},
	booktitle = {Proceedings of ICPC 2010 (18th IEEE International Conference on Program Comprehension)},
	year = {2010},
	note = {"We want to extract source code fragments from e-mail messages. To do this, we first need to select e-mails that contain source code fragments, and then we extract such fragments from the content in which they are enclosed."

"we manually build a statistically significant benchmark taking sample e- mails from five unrelated open source Java software systems."

},
	pages = {24-33},
	abstract = {E-mails, used by developers and system users to communicate over a broad range of topics, offer a valuable source of information. If archived, e-mails can be mined to support program comprehension activities and to provide views of a software system that are alternative and complementary to those offered by the source code.

However, e-mails are written in natural language, and therefore contain noise that makes it difficult to retrieve the important data. Thus, before conducting an effective system analysis and extracting data for program comprehension, it is necessary to select the relevant messages, and to expose only the meaningful information.

In this work we focus both on classifying e-mails that hold fragments of the source code of a system, and on extracting the source code pieces inside the e-mail. We devised and analyzed a number of lightweight techniques to accomplish these tasks. To assess the validity of our techniques, we manually inspected and annotated a statistically significant number of e-mails from five unrelated open source software systems written in Java. With such a benchmark in place, we measured the effectiveness of each technique in terms of precision and recall.},
	keywords = {argouml, email, freenet, jmeter, mailing lists, mina, natural language, openjpa, source code},
	url = {http://www.inf.usi.ch/phd/bacchelli/publications.php},
	attachments = {https://flosshub.org/sites/flosshub.org/files/icpc2010.pdf},
	author = {Bacchelli, Alberto and D{\textquoteright}Ambros, Marco and Lanza, Michele}
}
@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 {1257,
	title = {The Importance of Social Network Structure in the Open Source Software Developer Community},
	booktitle = {2010 43rd Hawaii International Conference on System Sciences},
	year = {2010},
	note = {"Using data from the SourceForge Research Data Archive [2, 9] and the new dataset of concurrent versions system (CVS) metadata described in [8]..." (M. Van Antwerp. Studying open source versioning metadata. Master{\textquoteright}s thesis, University of NotreDame, Notre Dame, IN, January 2009)
"To measure long-term popularity, we used the SourceForge activity percentile."},
	pages = {1 - 10},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Honolulu, Hawaii, USA},
	abstract = {This paper outlines the motivations and methods for analyzing the developer network of open source software (OSS) projects. Previous work done by Hinds [5] suggested social network structure was instrumental towards the success of an OSS project, as measured by activity and output. The follow-up paper by Hinds [4] discovered that his hypotheses, based on social network theory and previous research on the importance of subgroup connectedness, were vastly different than the results of his study of over 100 successful OSS projects. He concluded that the social network structure had no significant effect on project success. We outline how his approach disregarded potentially important factors and through a new study evaluate the role of the OSS developer network as it pertains to long-term project popularity. We also present an initial investigation into the adequacy of using the SourceForge activity percentile as a long-term success metric. In contrast with Hinds, we show that previously existing developer-developer ties are an indicator of past and future project popularity.},
	keywords = {developers, popularity, project success, social network analysis, sourceforge, srda},
	isbn = {978-1-4244-5509-6},
	doi = {10.1109/HICSS.2010.385},
	attachments = {https://flosshub.org/sites/flosshub.org/files/07-06-07.pdf},
	author = {Matthew Van Antwerp and Madey, Greg}
}
@proceedings {1379,
	title = {Learning in Open Source Software (OSS) Development: How Developer Interactions in Culturally Diverse Projects Impact the Acquisition of Collaboration and Learning Skills},
	year = {2010},
	abstract = {Participants in an OSS/FLOSS development project often span national and organizational boundaries, as developers from different countries and corporations join the project. A project team{\textquoteright}s national and organizational culture creates opportunities for learning from others, but may also lead to conflict and inhibit learning. This research examines developers{\textquoteright} learning in an OSS project, and the cultural context in which learning takes place. We focus on single- and doubleloop learning and examine the impact of the team{\textquoteright}s national and organizational culture on a developer{\textquoteright}s learning. Archival and survey data are collected from two large-scale Sourceforge projects. This research can contribute to the OSS literature by examining the impact of team interactions on developers{\textquoteright} learning. Practically, administrators and managers stand to gain insight into the learning benefits of participation in OSS projects, and thus better assess their value as a training ground for global software development.},
	keywords = {sourceforge},
	url = {http://aisel.aisnet.org/icis2010_submissions/66/},
	author = {Diamant, I. and Daniel, S.L.}
}
@conference {bird2010lee,
	title = {{Linkster: Enabling Efficient Manual Mining}},
	booktitle = {Demonstration Track, Proceedings of the 17th SIGSOFT Symposium on Foundations of Software Engineering},
	year = {2010},
	note = {"LINKSTER efficiently displays, integrates, and allows inspection and annotation of information from three main sources of data: source code repositories, developer mailing lists archives, and bug tracking databases. LINKSTER requires access to a source code repository for file content and a database which contains the raw mined repository, mailing list, and bug tracking information. All notes and annotations made by the user are also recorded in the database."},
	publisher = {ACM},
	organization = {ACM},
	abstract = {While many uses of mined software engineering data are automatic in nature, some techniques and studies either require, or can be improved, by manual methods. Unfortunately, manually inspecting, analyzing, and annotating mined data can be difficult and tedious, especially when information from multiple sources must be integrated. Oddly, while there are numerous tools and frameworks for automatically mining and analyzing data, there is a dearth of tools which facilitate manual methods. To fill this void, we have developed LINKSTER, a tool which integrates data from bug databases, source code repositories, and mailing list archives to allow manual inspection and annotation. LINKSTER has already been used successfully by an OSS project lead to obtain data for one empirical study.},
	keywords = {artifacts, bug, bug tracking, data mining, email, mailing lists, open source, source code},
	attachments = {https://flosshub.org/sites/flosshub.org/files/bird2010lee.pdf},
	author = {Christian Bird and Adrian Bachman and Rahman, Foyzur and Bernstein, Abraham}
}
@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 {956,
	title = {Mining security changes in FreeBSD},
	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 = {90 - 93},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Cape Town, South Africa},
	abstract = {Current research on historical project data is rarely touching on the subject of security related information. Learning how security is treated in projects and which parts of a software are historically security relevant or prone to security changes can enhance the security strategy of a software project. We present a mining methodology for security related changes by modifying an existing method of software repository analysis. We use the gathered security changes to find out more about the nature of security in the FreeBSD project and we try to establish a link between the identified security changes and a tracker for security issues (security advisories). We give insights how security is presented in the FreeBSD project and show how the mined data and known security problems are connected.},
	keywords = {freebsd, msr challenge, security},
	isbn = {978-1-4244-6802-7},
	doi = {10.1109/MSR.2010.5463289},
	author = {Mauczka, Andreas and Schanes, Christian and Fankhauser, Florian and Bernhart, Mario and Grechenig, Thomas}
}
@conference {964,
	title = {Mining subclassing directives to improve framework reuse},
	booktitle = {2010 7th IEEE Working Conference on Mining Software Repositories (MSR 2010)2010 7th IEEE Working Conference on Mining Software Repositories (MSR 2010)},
	year = {2010},
	pages = {141 - 150},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Cape Town, South Africa},
	abstract = {To help developers in using frameworks, good documentation is crucial. However, it is a challenge to create high quality documentation especially of hotspots in white-box frameworks. This paper presents an approach to documentation of object-oriented white-box frameworks which mines from client code four different kinds of documentation items, which we call subclassing directives. A case study on the Eclipse JFace user-interface framework shows that the approach can improve the state of API documentation w.r.t. subclassing directives.},
	keywords = {api, documentation, eclipse, frameworks, jface, source code},
	isbn = {978-1-4244-6802-7},
	doi = {10.1109/MSR.2010.5463347},
	attachments = {https://flosshub.org/sites/flosshub.org/files/141Mining-Subclassing-Directives-to-Improve-Framework-Reuse.pdf},
	author = {Bruch, Marcel and Mezini, Mira and Monperrus, Martin}
}
@conference {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.}
}
@book {1249,
	title = {Open Source Software Developer and Project Networks},
	series = {IFIP Advances in Information and Communication TechnologyOpen Source Software: New Horizons},
	volume = {319},
	year = {2010},
	note = {no information on data gathering procedures},
	pages = {407 - 412},
	publisher = {Springer Berlin Heidelberg},
	organization = {Springer Berlin Heidelberg},
	address = {Berlin, Heidelberg},
	abstract = {This paper outlines complex network concepts and how social networks are built from Open Source Software (OSS) data. We present an initial study of the social networks of three different OSS forges, BerliOS Developer, GNU Savannah, and SourceForge. Much research has been done on snapshot or conflated views of these networks, especially SourceForge, due to the size of the SourceForge community. The degree distribution, connectedness, centrality, and scale-free nature of SourceForge has been presented for the network at particular points in time. However, very little research has been done on how the network grows, how connections were made, especially during its infancy, and how these metrics evolve over time. },
	keywords = {berlios, savannah, sourceforge},
	isbn = {978-3-642-13244-5},
	issn = {1861-2288},
	doi = {10.1007/978-3-642-13244-5_39},
	author = {Madey, G. and van Antwerp, M.},
	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 {949,
	title = {Predicting the severity of a reported bug},
	booktitle = {2010 7th IEEE Working Conference on Mining Software Repositories (MSR 2010)2010 7th IEEE Working Conference on Mining Software Repositories (MSR 2010)},
	year = {2010},
	pages = {1 - 10},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Cape Town, South Africa},
	abstract = {The severity of a reported bug is a critical factor in deciding how soon it needs to be fixed. Unfortunately, while clear guidelines exist on how to assign the severity of a bug, it remains an inherent manual process left to the person reporting the bug. In this paper we investigate whether we can accurately predict the severity of a reported bug by analyzing its textual description using text mining algorithms. Based on three cases drawn from the open-source community (Mozilla, Eclipse and GNOME), we conclude that given a training set of sufficient size (approximately 500 reports per severity), it is possible to predict the severity with a reasonable accuracy (both precision and recall vary between 0.65-0.75 with Mozilla and Eclipse; 0.70-0.85 in the case of GNOME).},
	keywords = {bug reports, eclipse, gnome, mozilla, severity, text mining},
	isbn = {978-1-4244-6802-7},
	doi = {10.1109/MSR.2010.5463284},
	attachments = {https://flosshub.org/sites/flosshub.org/files/1lamkanfiDemeyer1.pdf},
	author = {Lamkanfi, Ahmed and Demeyer, Serge and Giger, Emanuel and Goethals, Bart}
}
@conference {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 {1222,
	title = {Responsiveness as a measure for assessing the health of OSS ecosystems},
	booktitle = {Second International Workshop on Building Sustainable Open Source Communities (OSCOMM 2010)},
	year = {2010},
	note = {"Data was collected from the GMANE (gmane.org) archives of the SourceForge {\textquotedblleft}Nagios-devel{\textquotedblright} mailing list for the period from January 2004 to October 2009". response time, responsiveness. "},
	month = {05/2010},
	abstract = {The health of an Open Source ecosystem is an important decision factor when considering the adoption of Open Source software or when monitoring a seeded Open Source project. In this paper we introduce responsiveness as a qualitative measure of the quality of replies within mailing lists, which can be used for assessing ecosystem health. We consider one specific metric of responsiveness in this paper, and that is the response time of follow-up messages in mailing lists. We also describe a way for characterising the nature of communication in messages with short and long response times. The approach is tested in the context of the Nagios project, and we particularly focus on the responsiveness for contributors acting in their professional roles as core developers. Our contribution is a step towards a deeper understanding of voluntary support provided in mailing lists of OSS projects.},
	keywords = {email, email archives, gmane, mailing lists, nagios, response time, sourceforge},
	attachments = {https://flosshub.org/sites/flosshub.org/files/osscomm002.pdf},
	author = {Gamalielsson, Jonas and Lundell, Bj{\"o}rn and Lings, Brian}
}
@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}
}
@mastersthesis {barcomb:2010:sociability,
	title = {The Sociability of Free Software: A GNU Look at Free Software Identified Businesses as Social Entrepreneurships},
	year = {2010},
	school = {Maastricht University},
	type = {masters},
	abstract = {This research strives to address the gap in the literature surrounding companies which identify with the philosophical values associated with the Free Software movement, which have historically been associated with Open Source businesses. It investigates whether ethically-motivated Free Software identified companies resemble social entrepreneurships. This work also examines whether there are significant differences between the business practices of Free Software identified companies, Free Software, and Open Source enterprises in order to assess if it is appropriate to address them as a group. The study is based on seven case studies, and includes one company which is a Free Software business, but does not identify with the Free Software philosophy, as well as one company which is ethically-motivated but identifies with Open Source rather than Free Software. The results indicate that there is good reason to believe that adherence to Free Software philosophy creates socially-aware businesses, which may be social entrepreneurships. No problems were discovered with the practice of grouping together Free Software and Open Source companies in the study of business practices, provided that a broad definition of success is used.
},
	keywords = {free software, open source software, public good, small business, social entrepreneurship, social ventures},
	url = {http://barcomb.org/cgi/paper.cgi?paper=barcomb:2010:sociability},
	attachments = {https://flosshub.org/sites/flosshub.org/files/barcomb-2010-sociability.pdf},
	author = {Barcomb, Ann}
}
@conference {Meirelles:2010:SRS:1915078.1916012,
	title = {A Study of the Relationships between Source Code Metrics and Attractiveness in Free Software Projects},
	booktitle = {Proceedings of the 2010 Brazilian Symposium on Software Engineering},
	series = {SBES {\textquoteright}10},
	year = {2010},
	pages = {11{\textendash}20},
	publisher = {IEEE Computer Society},
	organization = {IEEE Computer Society},
	address = {Washington, DC, USA},
	abstract = {A significant number of Free Software projects has been widely used and considered successful. However, there is an even larger number of them that cannot overcome the initial steps towards building an active community of users and developers. In this study, we investigated whether there are relationships between source code metrics and attractiveness, i.e., the ability of a project to attract users and developers. To verify these relationships, we analyzed 6,773 Free Software projects from the SourceForge.net repository. The results indicated that attractiveness is indeed correlated to some source code metrics. This suggests that measurable attributes of the project source code somehow affect the decision to contribute to and adopt a Free Software. The findings described in this paper show that it is relevant for project leaders to monitor source code quality, particularly a few objective metrics, since these can have a positive influence in projects chances of forming a community of contributors and users around their software, enabling further enhancement in quality.},
	keywords = {source code, source code analysis, sourceforge, user satisfaction, users},
	isbn = {978-0-7695-4273-7},
	doi = {10.1109/SBES.2010.27},
	url = {http://dx.doi.org/10.1109/SBES.2010.27},
	attachments = {https://flosshub.org/sites/flosshub.org/files/sourcecode_attractiveness.pdf},
	author = {Meirelles, Paulo and Santos Jr., Carlos and Miranda, Joao and Kon, Fabio and Terceiro, Antonio and Chavez, Christina}
}
@conference {1223,
	title = {Success and Abandonment in Open Source Commons: Selected Findings from an Empirical Study of Sourceforge.net Projects},
	booktitle = {Second International Workshop on Building Sustainable Open Source Communities (OSCOMM 2010)},
	year = {2010},
	note = {"we utilize data collected from August through October 2006 on 107,747 OSS projects hosted on the open source hosting site Sourceforge.net (SF henceforth). We combined SF project data gathered by the FLOSSmole project (Howison et al., 2006) with other SF data we {\textquotedblleft}crawled{\textquotedblright} ourselves"},
	month = {05/2010},
	abstract = {Some open source software collaborations are sustained over long periods of time and across several versions of a software product, while others become abandoned even before the first version of the product has been developed. In this study, we identify factors that might be responsible for one or the other of these collaborative trajectories. We examine 107,747 open source software projects hosted on Sourceforge.net in August 2006 using data available through the FLOSSmole Project. We employ Classification and Regression Tree modeling and Random Forests statistical approaches to begin to establish an understanding of how various project attributes, especially physical and community ones, contribute to project success or abandonment. We find that factors associated with success and abandonment differ for projects in the early stage of development (pre-first release) compared to projects that have had a first release, and that product utility, project vision, leadership, and group-size are associated with success in open source collaborations. We also find that successful open source projects exist across all types of software and not simply in areas associated with the open source {\textquotedblleft}movement.{\textquotedblright} Other evidence suggests that Sourceforge.net may play an important role in {\textquotedblleft}intellectual match-making.{\textquotedblright}},
	keywords = {abandonment, flossmole, metadata, project failure, project success, sourceforge, time},
	attachments = {https://flosshub.org/sites/flosshub.org/files/osscomm003.pdf},
	author = {Schweik, C. M. and English, R. and Paienjton, Q. and Haire, S.}
}
@article {1385,
	title = {Survival analysis on the duration of open source projects},
	journal = {Information and Software Technology},
	volume = {52},
	year = {2010},
	note = {"For the purposes of our study we used data coming only from source code repositories."},
	month = {9/2010},
	pages = {902 - 922},
	abstract = {Context

Open source (FLOSS) project survivability is an important piece of information for many open source stakeholders. Coordinators of open source projects would like to know the chances for the survival of the projects they coordinate. Companies are also interested in knowing how viable a project is in order to either participate or invest in it, and volunteers want to contribute to vivid projects.
Objective

The purpose of this article is the application of survival analysis techniques for estimating the future development of a FLOSS project.
Method

In order to apply such approach, duration data regarding FLOSS projects from the FLOSSMETRICS (This work was partially supported by the European Community{\textquoteright}s Sixth Framework Program under the Contract FP6-033982) database were collected. Such database contains metadata for thousands of FLOSS projects, derived from various forges. Subsequently, survival analysis methods were employed to predict the survivability of the projects, i.e. their probability of continuation in the future, by examining their duration, combined with other project characteristics such as their application domain and number of committers.
Results

It was shown how probability of termination or continuation may be calculated and how a prediction model may be built to upraise project future. In addition, the benefit of adding more committers to FLOSS projects was quantified.
Conclusion

Analysis results demonstrate the usefulness of the proposed framework for assessing the survival probability of a FLOSS project.
},
	keywords = {flossmetrics, prediction, source code, survival analysis},
	issn = {09505849},
	doi = {10.1016/j.infsof.2010.05.001},
	author = {Samoladas, Ioannis and Lefteris Angelis and Ioannis Stamelos}
}
@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 {anbalagan2010towards,
	title = {Towards a bayesian approach in modeling the disclosure of unique security faults in open source projects},
	booktitle = {Software Reliability Engineering (ISSRE), 2010 IEEE 21st International Symposium on},
	year = {2010},
	pages = {101{\textendash}110},
	publisher = {IEEE},
	organization = {IEEE},
	abstract = {Software security has both an objective and a subjective component. A lot of the information available about that today is focused on security vulnerabilities and their disclosure. It is less frequent that security breaches and failures rates are reported, even in open source projects. Disclosure of security problems can take several forms. A disclosure can be accompanied by a release of the fix for the problem, or not. The latter category can be further divided into {\textquotedblright}voluntary{\textquotedblright} and {\textquotedblright}involuntary{\textquotedblright} security issues. In widely used software there is also considerable variability in the operational profile under which the software is used. This profile is further modified by attacks on the software that may be triggered by security disclosures. Therefore a comprehensive model of software security qualities of a product needs to incorporate both objective measures, such as security problem disclosure, repair and, failure rates, as well as less objective metrics such as implied variability in the operational profile, influence of attacks, and subjective impressions of exposure and severity of the problems, etc. We show how a classical Bayesian model can be adapted for use in the security context. The model is discussed and assessed using data from three open source software project releases. Our results show that the model is suitable for use with a certain subset of disclosed security faults, but that additional work will be needed to identify appropriate shape and scaling functions that would accurately reflect end-user perceptions associated with security problems.},
	keywords = {security},
	url = {http://ai2-s2-pdfs.s3.amazonaws.com/edcf/0b13ae1e6317c7e31f6b8783f669b978ffb3.pdf},
	attachments = {https://flosshub.org/sites/flosshub.org/files/0b13ae1e6317c7e31f6b8783f669b978ffb3.pdf},
	author = {Anbalagan, Prasanth and Vouk, Mladen}
}
@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.}
}
@article {1387,
	title = {Using the DEMO methodology for modeling open source software development processes},
	journal = {Information and Software Technology},
	volume = {52},
	year = {2010},
	month = {6/2010},
	pages = {656 - 671},
	abstract = {Context

Open source software development (OSSD) process modeling has received increasing interest in recent years. These efforts aim to identify common elements in the development process between multiple open source software (OSS) projects. However, the complexity inherent to OSSD process modeling puts significant demands on the modeling language.
Objective

In this paper, we propose that the Design and Engineering Methodology for Organizations (DEMO) may provide an interesting alternative to develop OSSD process models. DEMO exhibits two unique features within the context of OSSD process modeling. First, DEMO analyzes processes at the ontological level and provides high-level process descriptions, instead of focusing on the implementation level. Second, DEMO studies the communication patterns between human actors, instead of the sequences in which activities are performed.
Method

We investigate the feasibility of using DEMO to construct OSSD process models by means of a case study. DEMO models were constructed to describe the NetBeans Requirements and Release process. In addition, the quality of these DEMO models was evaluated using a quality framework for conceptual modeling.
Results

Our results showed that our DEMO models exhibited a high level of abstraction, thereby reducing the complexity of the OSSD process models. In addition, the evaluation of the models developed in this paper by using the quality framework for conceptual modeling showed that the models were of high quality.
Conclusions

We have shown that the DEMO methodology can be successfully used to model OSSD processes and to obtain abstract and high-quality OSSD process models. However, given some potential drawbacks with respect to understandability and implementability, we primarily propose the use of DEMO within OSSD process modeling as an analysis tool that should be complemented with other techniques and models for communication and reenactment purposes.},
	keywords = {DEMO, Enterprise ontology, open source software, Software process modeling},
	issn = {09505849},
	doi = {10.1016/j.infsof.2010.02.002},
	url = {http://www.sciencedirect.com/science/article/pii/S0950584910000157},
	author = {Huysmans, Philip and Ven, Kris and Verelst, Jan}
}
@conference {969,
	title = {Validity of network analyses in Open Source 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},
	note = {"We have mined archival records of developer mailing lists to generate reply-to social networks for the three OSS projects: Apache, MySQL, and Perl."

"For each of these projects, we construct an information flow network based on messages that are sent as replies to previous messages....We use this methodology on all mined data to create a network of mailing list participants. "},
	pages = {201 - 209},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Cape Town, South Africa},
	abstract = {Social network methods are frequently used to analyze networks derived from Open Source Project communication and collaboration data. Such studies typically discover patterns in the information flow between contributors or contributions in these projects. Social network metrics have also been used to predict defect occurrence. However, such studies often ignore or side-step the issue of whether (and in what way) the metrics and networks of study are influenced by inadequate or missing data. In previous studies email archives of OSS projects have provided a useful trace of the communication and co-ordination activities of the participants. These traces have been used to construct social networks that are then subject to various types of analysis. However, during the construction of these networks, some assumptions are made, that may not always hold; this leads to incomplete, and sometimes incorrect networks. The question then becomes, do these errors affect the validity of the ensuing analysis? In this paper we specifically examine the stability of network metrics in the presence of inadequate and missing data. The issues that we study are: 1) the effect of paths with broken information flow (i.e. consecutive edges which are out of temporal order) on measures of centrality of nodes in the network, and 2) the effect of missing links on such measures. We demonstrate on three different OSS projects that while these issues do change network topology, the metrics used in the analysis are stable with respect to such changes.},
	keywords = {apache, email archives, mailing lists, missing data, mysql, perl, social networks},
	isbn = {978-1-4244-6802-7},
	doi = {10.1109/MSR.2010.5463342},
	attachments = {https://flosshub.org/sites/flosshub.org/files/201NetworkAnalysis.pdf},
	author = {Nia, Roozbeh and Christian Bird and Devanbu, Premkumar and Filkov, Vladimir}
}
@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}
}
@article {1239,
	title = {Weaving a Semantic Web Across OSS Repositories},
	journal = {International Journal of Open Source Software and Processes},
	volume = {2},
	year = {2010},
	month = {32/2010},
	pages = {29 - 40},
	abstract = {Several public repositories and archives of {\textquotedblleft}facts{\textquotedblright} about libre software projects, maintained either by open source communities or by research communities, have been flourishing over the Web in recent years. These have enabled new analysis and support for new quality assurance tasks. This paper presents some complementary existing tools, projects and models proposed both by OSS actors or research initiatives that are likely to lead to useful future developments in terms of study of the FLOSS phenomenon, and also to the very practitioners in the FLOSS development projects. A goal of the research conducted within the HELIOS project is to address bugs traceability issues. In this regard, the authors investigate the potential of using Semantic Web technologies in navigating between many different bugtracker systems scattered all over the open source ecosystem. By using Semantic Web techniques, it is possible to interconnect the databases containing data about open-source software projects development, which enables OSS partakers to identify resources, annotate them, and further interlink those using dedicated properties and collectively designing a distributed semantic graph.},
	keywords = {archive, bug, bugtracker, database, debian, forge, interoperability, ontology, OSLC-CM, RDF, repository of repositories, semantic, semantic Web},
	issn = {1942-3934},
	doi = {10.4018/jossp.2010040103},
	attachments = {https://flosshub.org/sites/flosshub.org/files/wopdasd2009-olivier-berger.pdf},
	author = {Olivier Berger and Valentin Vlasceanu and Christian Bac and Quang Vu Dang and Lauriere, St{\'e}phane}
}
@article {10.1109/TSE.2010.63,
	title = {What Makes a Good Bug Report?},
	journal = {IEEE Transactions on Software Engineering},
	volume = {36},
	year = {2010},
	note = {"o find out which matter most, we asked 872 devel-
opers from the APACHE, ECLIPSE, and MOZILLA projects to:
1. Complete a survey on important information in bug reports and the problems they faced with them. We received a total of 156 responses to our survey (Section 2 and 3).
2. Rate the quality of bug reports from very poor to very good on a five-point Likert scale [22]. We received a total of 1,186 votes for 289 randomly selected bug reports (Section 4).
In addition, we asked 1,354 reporters1 from the same projects to complete a similar survey, out of which 310 responded. "},
	pages = {618-643},
	publisher = {IEEE Computer Society},
	address = {Los Alamitos, CA, USA},
	abstract = {In software development, bug reports provide crucial information to developers. However, these reports widely differ in their quality. We conducted a survey among developers and users of APACHE, ECLIPSE, and MOZILLA to find out what makes a good bug report.
The analysis of the 466 responses revealed an information mis- match between what developers need and what users supply. Most developers consider steps to reproduce, stack traces, and test cases as helpful, which are at the same time most difficult to provide for users. Such insight is helpful to design new bug tracking tools that guide users at collecting and providing more helpful information.
Our CUEZILLA prototype is such a tool and measures the quality of new bug reports; it also recommends which elements should be added to improve the quality. We trained CUEZILLA on a sample of 289 bug reports, rated by developers as part of the survey. In our experiments, CUEZILLA was able to predict the quality of 31{\textendash}48\% of bug reports accurately.},
	keywords = {bug report, Survey},
	issn = {0098-5589},
	doi = {http://doi.ieeecomputersociety.org/10.1109/TSE.2010.63},
	url = {http://dl.acm.org/citation.cfm?id=1453146},
	attachments = {https://flosshub.org/sites/flosshub.org/files/bettenburg-fse-2008.pdf},
	author = {Zimmermann, Thomas and Premraj, Rahul and Bettenburg, Nicolas and Sascha Just and Schroter, Adrian and Weiss, Cathrin}
}
@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 {937,
	title = {Assigning bug reports using a vocabulary-based expertise model of developers},
	booktitle = {2009 6th IEEE International Working Conference on Mining Software Repositories (MSR)2009 6th IEEE International Working Conference on Mining Software Repositories},
	year = {2009},
	pages = {131 - 140},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Vancouver, BC, Canada},
	abstract = {For popular software systems, the number of daily submitted bug reports is high. Triaging these incoming reports is a time consuming task. Part of the bug triage is the assignment of a report to a developer with the appropriate expertise. In this paper, we present an approach to automatically suggest developers who have the appropriate expertise for handling a bug report. We model developer expertise using the vocabulary found in their source code contributions and compare this vocabulary to the vocabulary of bug reports. We evaluate our approach by comparing the suggested experts to the persons who eventually worked on the bug. Using eight years of Eclipse development as a case study, we achieve 33.6\% top-1 precision and 71.0\% top-10 recall.},
	keywords = {bug reports, bugzilla, develect, developers, eclipse, expertise, scm},
	isbn = {978-1-4244-3493-0},
	doi = {10.1109/MSR.2009.5069491},
	attachments = {https://flosshub.org/sites/flosshub.org/files/131AssigningBugReports.pdf},
	author = {Matter, Dominique and Kuhn, Adrian and Nierstrasz, Oscar}
}
@conference {943,
	title = {Automatic labeling of software components and their evolution using log-likelihood ratio of word frequencies in source 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 = {175 - 178},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Vancouver, BC, Canada},
	abstract = {As more and more open-source software components become available on the Internet we need automatic ways to label and compare them. For example, a developer who searches for reusable software must be able to quickly gain an understanding of retrieved components. This understanding cannot be gained at the level of source code due to the semantic gap between source code and the domain model. In this paper we present a lexical approach that uses the log-likelihood ratios of word frequencies to automatically provide labels for software components. We present a prototype implementation of our labeling/comparison algorithm and provide examples of its application. In particular, we apply the approach to detect trends in the evolution of a software system.},
	keywords = {frequency, hapax, information retrieval, java, junit, keywords, labeling, source code},
	isbn = {978-1-4244-3493-0},
	doi = {10.1109/MSR.2009.5069499},
	attachments = {https://flosshub.org/sites/flosshub.org/files/175AutomaticLabeling.pdf},
	author = {Kuhn, Adrian}
}
@article {1237,
	title = {Bridging the Gap between Agile and Free Software Approaches},
	journal = {International Journal of Open Source Software and Processes},
	volume = {1},
	year = {2009},
	month = {31/2009},
	pages = {58 - 71},
	abstract = {Agile sprints are short events where a small team collocates in order to work on particular aspects of the overall project for a short period of time. Sprinting is a process that has been observed also in Free Software projects: these two paradigms, sharing common principles and values have shown several commonalities of practice. This article evaluates the impact of sprinting on a Free Software project through the analysis of code repository logs: sprints from two Free Software projects (Plone and KDE PIM) are assessed and two hypotheses are formulated: do sprints increase productivity? Are Free Software projects more productive after sprints compared with before? The primary contribution of this article is to show how sprinting creates a large increase in productivity both during the event, and immediately after the event itself: this argues for more in-depth studies focussing on the nature of sprinting.},
	keywords = {agile, kde, lines of code, loc, plone, productivity, scm, scrum, sprints, subversion},
	issn = {1942-3934},
	doi = {10.4018/jossp.2009010104},
	author = {Paul J. Adams and Capiluppi, Andrea}
}
@conference {929,
	title = {Code siblings: Technical and legal implications of copying code between 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 = {81 - 90},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Vancouver, BC, Canada},
	abstract = {Source code cloning does not happen within a single system only. It can also occur between one system and another. We use the term code sibling to refer to a code clone that evolves in a different system than the code from which it originates. Code siblings can only occur when the source code copyright owner allows it and when the conditions imposed by such license are not incompatible with the license of the destination system. In some situations copying of source code fragments are allowed - legally - in one direction, but not in the other. In this paper, we use clone detection, license mining and classification, and change history techniques to understand how code siblings - under different licenses - flow in one direction or the other between Linux and two BSD Unixes, FreeBSD and OpenBSD. Our results show that, in most cases, this migration appears to happen according to the terms of the license of the original code being copied, favoring always copying from less restrictive licenses towards more restrictive ones. We also discovered that sometimes code is inserted to the kernels from an outside source.},
	keywords = {bsd, fossology, freebsd, linux, openbsd, source code},
	isbn = {978-1-4244-3493-0},
	doi = {10.1109/MSR.2009.5069483},
	attachments = {https://flosshub.org/sites/flosshub.org/files/81CodeSiblings.pdf},
	author = {Daniel M. German and Di Penta, Massimiliano and Gueheneuc, Yann-Gael and Antoniol, Giuliano}
}
@article {1241,
	title = {Collaborative Software Development Using R-Forge},
	journal = {The R Journal},
	volume = {1},
	number = {1},
	year = {2009},
	month = {05/2009},
	pages = {9-14},
	abstract = {Open source software (OSS) is typically created in a decentralized self-organizing process by a community of developers having the same or similar interests (see the famous essay by Raymond, 1999). A key factor for the success of OSS over the last two decades is the Internet: Developers who rarely meet face-to-face can employ new means of communication, both for rapidly writing and deploying software (in the spirit of Linus Torvald{\textquoteright}s {\textquotedblleft}release early, release often paradigm{\textquotedblright}). Therefore, many tools emerged that assist a collaborative software development process, including in particular tools for source code management (SCM) and version control.
In the R world, SCM is not a new idea; in fact, the R Development Core Team has always been using SCM tools for the R sources, first by means of Concurrent Versions System (CVS, see Cederqvist et al., 2006), and then via Subversion (SVN, see Pilato et al., 2004). A central repository is hosted by ETH Zürich mainly for managing the development of the base R system. Mailing lists like R-help, R-devel and many others are currently the main communication channels in the R community.
First, we present the core features that R- Forge offers to the R community. Second, we give a hands-on tutorial on how users and developers can get started with R-Forge. In particular, we illustrate how people can register, set up new projects, use R- Forge{\textquoteright}s SCM facilities, provide their packages on R-Forge, host a project-specific website, and how package maintainers submit a package to the Compre- hensive R Archive Network (CRAN, http://CRAN. R-project.org/). Finally, we summarize recent developments and give a brief outlook to future work.},
	keywords = {forge, R, scm, source code repositories, statistics},
	attachments = {https://flosshub.org/sites/flosshub.org/files/rjournal.pdf},
	author = {Stefan Theu{\ss}l and Achim Zeileis}
}
@conference {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}
}
@article {1414,
	title = {Competition and production of digital public goods},
	journal = {International Journal of Intelligent Control and Systems},
	volume = {14},
	number = {1},
	year = {2009},
	pages = {77-86},
	chapter = {77},
	abstract = {With the Internet has come the phenomenon of people volunteering to work on digital public goods such as open source software and online encyclopedia articles. Presumably, the success of individual public goods has an effect on attracting volunteers. However, the definition of success is ill-defined. This paper explores the impact of different success metrics on a simple public goods model. The findings show that the different success metrics considered do have an impact on the behavior of the model, with the largest differences being between consumer-oriented and producer-oriented metrics. This indicates that many proposed success metrics may be mapped into one of these two categories and within a category, all success metrics measure the same phenomenon. We argue that the characteristics of producer-oriented metrics more closely match real world phenomena, indicating that public goods are driven by producer, and not consumer, interests.},
	keywords = {digital public goods, FLOSS, open source software, sourceforge, success metrics, wikipedia},
	url = {http://www.public.asu.edu/~majansse/pubs/ijics2009.pdf},
	attachments = {https://flosshub.org/sites/flosshub.org/files/ijics2009.pdf},
	author = {Radtke, Nicholas P. and Janssen, Marco A.}
}
@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.687,
	title = {Easier Said than Done: An Empirical Investigation of Software Design and Quality in Open Source Software Development},
	journal = {2009 42nd Hawaii International Conference on System Sciences (HICSS 2009)},
	year = {2009},
	note = {"projects that do not exhibit obvious corporate or organizational sponsorship or involvement, projects with at least one software release in a relatively mature development stage (Beta or Production/Stable), projects exhibiting a minimum level of project activity, and products written only using Java."
"The frame includes approximately 180 projects from which a random sample of 46 was drawn"
"For each project, we sample each major software release (e.g. 1.x, 2.x) as our unit of analysis for a total of 203 releases."
"We calculate the degree of modularity for each major software release sampled using the source code contained in each release"
"To measure intrinsic software quality, we calculate the number of static bugs and software complexity based on objective evaluations of the source code included in the software release using two static source code analysis tools"
"To assess customer satisfaction, we use three measures of software quality previously identified in OSS research as a proxy for software quality and OSS project success [3]: number of bugs reported, percentage of bugs closed, and time to close bugs."},
	pages = {1-10},
	publisher = {IEEE Computer Society},
	address = {Los Alamitos, CA, USA},
	abstract = {We empirically examine the relationship between software design modularity and software quality in open source software (OSS) development projects. Conventional wisdom suggests that degree of software modularity affects software quality. An analysis of 203 software releases in 46 OSS projects hosted on SourceForge.net lends support for a more complex relationship between software modularity and software quality than conventional wisdom suggests. We find that software modularity is associated with reduced software complexity, an increased number of static software bugs, and a mixed relationship with the percentage of bugs closed. We do not find empirical evidence supporting any relationship between modularity and other measures of customer satisfaction. In addition to empirically testing the relationship between modularity and quality, we introduce new measures of software modularity and software quality. Implications are developed for the theory of modularity and the practice of software development.},
	keywords = {modularity, quality, source code, sourceforge},
	isbn = {978-0-7695-3450-3},
	doi = {http://doi.ieeecomputersociety.org/10.1109/HICSS.2009.687},
	attachments = {https://flosshub.org/sites/flosshub.org/files/09-14-05.pdf},
	author = {Conley, Caryn A. and Lee Sproull}
}
@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 {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 {1262,
	title = {An Exploratory Study on the Two New Trends in Open Source Software: End-Users and Service},
	booktitle = {2009 42nd Hawaii International Conference on System Sciences (HICSS 2009)},
	year = {2009},
	note = {used sourceforge data
"We created our dataset by restricting our attention to projects that have production/stable and mature development status"
"we limited our sample to two categories: developers and end-users/desktop"
"We manually compiled a total of 200 projects, 100 each of the most downloaded projects from developers and end-users/desktop categories during the period of March 4 to March 23, 2008. "},
	pages = {1 - 10},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Waikoloa, Hawaii, USA},
	abstract = {Many have been envisaging the emergence of Open Source Software (OSS) for general end-users and the enhancements in providing services and support, as the most critical factors for OSS success, and at the same time, the most critical issues which are holding back the OSS movement. While these two distinct waves in OSS evolution have become more observable, researchers have not yet explored the characteristics of these two distinct new waves. The current study found evidence for these two waves and further explored the two waves by empirically examining two hundred projects hosted in Sourceforge.net. We compared the characteristics of OSS projects that are intended for two disparate audiences: developers and end-users and found that projects for end-users supported more languages but also had more restrictive licenses as compared to projects for developers.},
	keywords = {developers, intended audiences, sourceforge},
	isbn = {978-0-7695-3450-3},
	doi = {10.1109/HICSS.2009.63},
	attachments = {https://flosshub.org/sites/flosshub.org/files/07-07-05.pdf},
	author = {Namjoo Choi and Chengular-Smith, I.}
}
@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 {936,
	title = {From work to word: How do software developers describe their work?},
	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 = {121 - 130},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Vancouver, BC, Canada},
	abstract = {Developers take notes about their work sessions, either to remember the work status and share it with collaborators, or because employers explicitly require this for project management matters. We report on an exploratory study which aims at understanding how software developers describe their work. We analyzed more than 750,000 work descriptions of about 2,000 professionals taken over 8 years in three settings. We observed several similarities in the content and time meta-data of work descriptions. Most frequent terms, such as top-30 performed activities, are used consistently. Particular templates such as ldquoACTION concerning ARTIFACT because of CAUSErdquo occur frequently. Developers described sessions that last 30-120 min. 4-16 times a day. Maintaining diaries seems to consume between 3-6\% of the total work time, and in 10\% of the sessions, developers did not describe their work in sufficient detail. We argue that our results make the first step towards automatically generating work diaries for software developers.},
	keywords = {apache, developers, diaries, eureka, mycomp, scm, work management system},
	isbn = {978-1-4244-3493-0},
	doi = {10.1109/MSR.2009.5069490},
	author = {Maalej, Walid and Happel, Hans-Jorg}
}
@article {Beecher2009739,
	title = {Identifying exogenous drivers and evolutionary stages in FLOSS projects},
	journal = {Journal of Systems and Software},
	volume = {82},
	number = {5},
	year = {2009},
	pages = {739 - 750},
	abstract = {The success of a Free/Libre/Open Source Software (FLOSS) project has been evaluated in the past through the number of commits made to its configuration management system, number of developers and number of users. Most studies, based on a popular FLOSS repository (SourceForge), have concluded that the vast majority of projects are failures. This study{\textquoteright}s empirical results confirm and expand conclusions from an earlier and more limited work. Not only do projects from different repositories display different process and product characteristics, but a more general pattern can be observed. Projects may be considered as early inceptors in highly visible repositories, or as established projects within desktop-wide projects, or finally as structured parts of FLOSS distributions. These three possibilities are formalized into a framework of transitions between repositories. The framework developed here provides a wider context in which results from FLOSS repository mining can be more effectively presented. Researchers can draw different conclusions based on the overall characteristics studied about an Open Source software project{\textquoteright}s potential for success, depending on the repository that they mine. These results also provide guidance to OSS developers when choosing where to host their project and how to distribute it to maximize its evolutionary success.},
	keywords = {developers, forge, forges, repositories, repository, scm, software repositories, sourceforge, success, users},
	issn = {0164-1212},
	doi = {DOI: 10.1016/j.jss.2008.10.026},
	url = {http://www.sciencedirect.com/science/article/B6V0N-4TVTJFS-1/2/e32ecee1bcb54bd4a5dff6d5e3daca8d},
	author = {Karl Beecher and Capiluppi, Andrea and Boldyreff, Cornelia}
}
@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}
}
@conference {942,
	title = {On mining data across software repositories},
	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 = {171 - 174},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Vancouver, BC, Canada},
	abstract = {Software repositories provide abundance of valuable information about open source projects. With the increase in the size of the data maintained by the repositories, automated extraction of such data from individual repositories, as well as of linked information across repositories, has become a necessity. In this paper we describe a framework that uses web scraping to automatically mine repositories and link information across repositories. We discuss two implementations of the framework. In the first implementation, we automatically identify and collect security problem reports from project repositories that deploy the Bugzilla bug tracker using related vulnerability information from the National Vulnerability Database. In the second, we collect security problem reports for projects that deploy the Launchpad bug tracker along with related vulnerability information from the National Vulnerability Database. We have evaluated our tool on various releases of Fedora, Ubuntu, Suse, RedHat, and Firefox projects. The percentage of security bugs identified using our tool is consistent with that reported by other researchers.},
	keywords = {bug reports, bugzilla, Fedora, Firefox, htmlscraper, integration, launchpad, national vulnerability database, RedHat, Suse, tracker, Ubuntu},
	isbn = {978-1-4244-3493-0},
	doi = {10.1109/MSR.2009.5069498},
	attachments = {https://flosshub.org/sites/flosshub.org/files/171MiningAcrossmsr09.pdf},
	author = {Anbalagan, Prasanth and Vouk, Mladen}
}
@conference {935,
	title = {Mining search topics from a code search engine usage log},
	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 = {111 - 120},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Vancouver, BC, Canada},
	abstract = {We present a topic modeling analysis of a year long usage log of Koders, one of the major commercial code search engines. This analysis contributes to the understanding of what users of code search engines are looking for. Observations on the prevalence of these topics among the users, and on how search and download activities vary across topics, leads 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 presents a general categorization of these topics that provides insights on the different ways code search engine users express their queries. The findings support the conclusion that existing code search engines provide only a subset of the various information needs of the users when compared to the categories of queries they look at.},
	keywords = {analysis, black duck, koders, log, logfile, search, source code},
	isbn = {978-1-4244-3493-0},
	doi = {10.1109/MSR.2009.5069489},
	author = {Bajracharya, Sushil and Lopes, Cristina}
}
@conference {928,
	title = {Mining source code to automatically split identifiers for software analysis},
	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 = {71 - 80},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Vancouver, BC, Canada},
	abstract = {Automated software engineering tools (e.g., program search, concern location, code reuse, quality assessment, etc.) increasingly rely on natural language information from comments and identifiers in code. The first step in analyzing words from identifiers requires splitting identifiers into their constituent words. Unlike natural languages, where space and punctuation are used to delineate words, identifiers cannot contain spaces. One common way to split identifiers is to follow programming language naming conventions. For example, Java programmers often use camel case, where words are delineated by uppercase letters or non-alphabetic characters. However, programmers also create identifiers by concatenating sequences of words together with no discernible delineation, which poses challenges to automatic identifier splitting. In this paper, we present an algorithm to automatically split identifiers into sequences of words by mining word frequencies in source code. With these word frequencies, our identifier splitter uses a scoring technique to automatically select the most appropriate partitioning for an identifier. In an evaluation of over 8000 identifiers from open source Java programs, our Samurai approach outperforms the existing state of the art techniques.},
	keywords = {java, samurai, sourceforge},
	isbn = {978-1-4244-3493-0},
	doi = {10.1109/MSR.2009.5069482},
	attachments = {https://flosshub.org/sites/flosshub.org/files/71EnslenandHillandPollockandVijayShanker.pdf},
	author = {Enslen, Eric and Hill, Emily and Pollock, Lori and Vijay-Shanker, K.}
}
@conference {932,
	title = {Mining the coherence of GNOME bug reports with statistical topic models},
	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 = {99 - 102},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Vancouver, BC, Canada},
	abstract = {We adapt latent Dirichlet allocation to the problem of mining bug reports in order to define a new information-theoretic measure of coherence. We then apply our technique to a snapshot of the GNOME Bugzilla database consisting of 431,863 bug reports for multiple software projects. In addition to providing an unsupervised means for modeling report content, our results indicate substantial promise in applying statistical text mining algorithms for estimating bug report quality. Complete results are available from our supplementary materials Web site at http://sourcerer.ics.uci.edu/msr2009/gnome_coherence.html.},
	keywords = {bug reports, bugzilla, gnome, msr challenge, quality, sourcerer},
	isbn = {978-1-4244-3493-0},
	doi = {10.1109/MSR.2009.5069486},
	author = {Linstead, Erik and Baldi, Pierre}
}
@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.}
}
@conference {DBLP:conf/msr/BirdRBHGD09,
	title = {The promises and perils of mining git},
	booktitle = {Proceedings of the 6th International Working Conference on Mining Software Repositories, MSR 2009},
	year = {2009},
	pages = {1-10},
	abstract = {We are now witnessing the rapid growth of decentralized source code management (DSCM) systems, in which every developer has her own repository. DSCMs facilitate a style of collaboration in which work output can flow sideways (and privately) between collaborators, rather than always up and down (and publicly) via a central repository. Decentralization comes with both the promise of new data and the peril of its misinterpretation. We focus on git, a very popular DSCM used in high-profile projects. Decentralization, and other features of git, such as automatically recorded contributor attribution, lead to richer content histories, giving rise to new questions such as "How do contributions flow between developers to the official project repository?" However, there are pitfalls. Commits may be reordered, deleted, or edited as they move between repositories. The semantics of terms common to SCMs and DSCMs sometimes differ markedly, potentially creating confusion. For example, a commit is immediately visible to all developers in centralized SCMs, but not in DSCMs. Our goal is to help researchers interested in DSCMs avoid these and other perils when mining and analyzing git data.},
	keywords = {dscm, git, mining, scm, source code},
	attachments = {https://flosshub.org/sites/flosshub.org/files/1promisePeril.pdf},
	author = {Christian Bird and Peter C. Rigby and Earl T. Barr and David J. Hamilton and Daniel M. Germ{\'a}n and Premkumar T. Devanbu}
}
@conference {bird2009pat,
	title = {{Putting it All Together: Using Socio-Technical Networks to Predict Failures}},
	booktitle = {Proceedings of the 17th International Symposium on Software Reliability Engineering},
	year = {2009},
	note = {First, we build each type of network separately and use network analysis on both to gather metrics for use in a predictive model. Second, we build a socio-technical network which combines the nodes and edges from both the dependency network and the contribution network and use metrics gathered from this network in a predictive model.
We evaluate our approach by collecting data from Mi- crosoft Windows Vista and ECLIPSE development and using logistic regression analysis.},
	abstract = {Studies have shown that social factors in development organizations have a dramatic effect on software quality. Separately, program dependency information has also been used successfully to predict which software components are more fault prone. Interestingly, the influence of these two phenomena have only been studied separately. Intuition and practical experience suggests, however, that task assignment (i.e. who worked on which components and how much) and dependency structure (which components have dependencies on others) together interact to influence the quality of the resulting software. We study the influence of combined socio-technical software networks on the fault-proneness of individual software components within a system. The network properties of a software component in this combined network are able to predict if an entity is failure prone with greater accuracy than prior methods which use dependency or contribution information in isolation. We evaluate our approach in different settings by using it on Windows Vista and across six releases of the Eclipse development environment including using models built from one release to predict failure prone components in the next release. We compare this to previous work. In every case, our method performs as well or better and is able to more accurately identify those software components that have more post-release failures, with precision and recall rates as high as 85\%.},
	keywords = {eclipse, microsoft, social network, vista, windows},
	attachments = {https://flosshub.org/sites/flosshub.org/files/bird2009pat.pdf},
	author = {Christian Bird and Nachiappan Nagappan and Devanbu, Premkumar and Gall, Harald and Brendan Murphy}
}
@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}
}
@conference {1066,
	title = {SourcererDB: An aggregated repository of statically analyzed and cross-linked open source Java projects},
	booktitle = {2009 6th IEEE International Working Conference on Mining Software Repositories (MSR)},
	year = {2009},
	pages = {183 - 186},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Vancouver, BC, Canada},
	abstract = {The open source movement has made vast quantities of source code available online for free, providing an extremely large dataset for empirical study and potential re-use. A major difficulty in exploiting this potential fully is that the data are currently scattered between competing source code repositories, none of which are structured for empirical analysis and cross-project comparison. As a result, software researchers and developers are left to compile their own datasets, resulting in duplicated effort and limited results. To address this challenge, we built SourcererDB, an aggregated repository of statically analyzed and cross-linked open source Java projects. SourcererDB contains local snapshots of 2,852 Java projects taken from Sourceforge, Apache and Java.net. These projects are statically analyzed to extract rich structural information, which is then stored in a relational database. References to entities in the 16,058 external jars are resolved and grouped, allowing for cross-project usage information to be accessed easily. This paper describes: (a) the mechanism for resolving and grouping these cross-project references, (b) the structure of and the metamodel for the SourcererDB repository, and (d) end-user dataset access mechanisms. Our goal in building SourcererDB is to provide a rich dataset of source code to facilitate the sharing of extracted data and to encourage reuse and repeatability of experiments.},
	keywords = {apache, java, java.net, source code, sourceforge, sourcerer},
	isbn = {978-1-4244-3493-0},
	doi = {10.1109/MSR.2009.5069501},
	author = {Ossher, Joel and Bajracharya, Sushil and Linstead, Erik and Baldi, Pierre and Lopes, Cristina}
}
@conference {945,
	title = {SourcererDB: An aggregated repository of statically analyzed and cross-linked open source Java 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 = {183 - 186},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Vancouver, BC, Canada},
	abstract = {The open source movement has made vast quantities of source code available online for free, providing an extremely large dataset for empirical study and potential resuse. A major difficulty in exploiting this potential fully is that the data are currently scattered between competing source code repositories, none of which are structured for empirical analysis and cross-project comparison. As a result, software researchers and developers are left to compile their own datasets, resulting in duplicated effort and limited results. To address this challenge, we built SourcererDB, an aggregated repository of statically analyzed and cross-linked open source Java projects. SourcererDB contains local snapshots of 2,852 Java projects taken from Sourceforge, Apache and Java.net. These projects are statically analyzed to extract rich structural information, which is then stored in a relational database. References to entities in the 16,058 external jars are resolved and grouped, allowing for cross-project usage information to be accessed easily. This paper describes: (a) the mechanism for resolving and grouping these cross-project references, (b) the structure of and the metamodel for the SourcererDB repository, and (d) end-user dataset access mechanisms. Our goal in building SourcererDB is to provide a rich dataset of source code to facilitate the sharing of extracted data and to encourage reuse and repeatability of experiments.},
	keywords = {apache, integration, java, java.net, project, repository, sourceforge, SourcererDB},
	isbn = {978-1-4244-3493-0},
	doi = {10.1109/MSR.2009.5069501},
	author = {Ossher, Joel and Bajracharya, Sushil and Linstead, Erik and Baldi, Pierre and Lopes, Cristina}
}
@conference {853,
	title = {Tagsplanations: Explaining Recommendations using Tags},
	booktitle = {International Conference on Intelligent User Interfaces},
	year = {2009},
	month = {02/08/2009},
	address = {Sanibel Island, FL},
	keywords = {recommender, SYSTEMS, tagging,},
	author = {Vig, J. and Sen, S. and Riedl, J.}
}
@article {1236,
	title = {Tools for the Study of the Usual Data Sources found in Libre Software Projects},
	journal = {International Journal of Open Source Software and Processes},
	volume = {1},
	year = {2009},
	month = {31/2009},
	pages = {24 - 45},
	abstract = {Due to the open nature of Free/Libre/Open Source software projects, researchers have gained access to a rich set of development-related information. Although this information is publicly available on the Internet, obtaining and analyzing it in a convenient way is not an easy task and many considerations have to be taken into account. In this paper we present the most important data sources that can be found in libre software projects and that are studied by the research community: source code, source code management systems, mailing lists and bug tracking systems. We will give advice for the problems that can be found when retrieving and preparing the data sources for a posterior analysis, as well as provide information about the tools that support these tasks.},
	keywords = {bug tracking systems, data sources, mailing lists, scm, tools},
	issn = {1942-3934},
	doi = {10.4018/jossp.2009010102},
	attachments = {https://flosshub.org/sites/flosshub.org/files/robles.pdf},
	author = {Gregorio Robles and Gonz{\'a}lez-Barahona, Jes{\'u}s M. and Izquierdo-Cortazar, Daniel and Herraiz, Israel}
}
@conference {Yatani:2009:UWO:1518701.1518853,
	title = {Understanding how and why open source contributors use diagrams in the development of Ubuntu},
	booktitle = {Proceedings of the 27th international conference on Human factors in computing systems},
	series = {CHI {\textquoteright}09},
	year = {2009},
	note = {"To examine how and why diagrams are used in any and all aspects of the software development process of an OSS project, we performed a series of semi-structured interviews with contributors to one particular effort{\textemdash}Ubuntu."
"Our study was divided into two phases. First, we asked participants to complete a questionnaire and provide us with information and materials for discussion. The questionnaire featured questions about participants{\textquoteright} OSS experience, project participation, their roles in each project, and basic demographics. We also asked participants to share diagrams they had created, modified or used as part of their work on Ubuntu. In the second phase of the study, we conducted semi-structured interviews with participants."},
	pages = {995{\textendash}1004},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {Some of the most interesting differences between Open Source Software (OSS) development and commercial co-located software development lie in the communication and collaboration practices of these two groups of developers. One interesting practice is that of diagramming. Though well studied and important in many aspects of co-located software development (including communication and collaboration among developers), its role in OSS development has not been thoroughly studied. In this paper, we report our investigation on how and why Ubuntu contributors use diagrams in their work. Our study shows that diagrams are not actively used in many scenarios where they commonly would in co-located software development efforts. We describe differences in the use and practices of diagramming, their possible reasons, and present design considerations for potential systems aimed at better supporting diagram use in OSS development.},
	keywords = {developers, diagramming, interviews, open source software (oss), software development, Ubuntu, visual representation},
	isbn = {978-1-60558-246-7},
	doi = {http://doi.acm.org/10.1145/1518701.1518853},
	url = {http://doi.acm.org/10.1145/1518701.1518853},
	author = {Yatani, Koji and Chung, Eunyoung and Jensen, Carlos and Truong, Khai N.}
}
@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}
}
@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}
}
@article {Au20099,
	title = {Virtual organizational learning in open source software development projects},
	journal = {Information \& Management},
	volume = {46},
	number = {1},
	year = {2009},
	pages = {9 - 15},
	abstract = {We studied virtual organizational learning in open source software (OSS) development projects. Specifically, our research focused on learning effects of OSS projects and the factors that affect the learning process. The number and percentage of resolved bugs and bug resolution time of 118 SourceForge.net OSS projects were used to measure the learning effects. Projects were characterized by project type, number and experience of developers, number of bugs, and bug resolution time. Our results provided evidence of virtual organizational learning in OSS development projects and support for several factors as determinants of performance. Team size was a significant predictor, with mid-sized project teams functioning best. Teams of three to seven developers exhibited the highest efficiency over time and teams of eight to 15 produced the lowest mean time for bug resolution. Increasing the percentage of bugs assigned to specific developers or boosting developer participation in other OSS projects also improved performance. Furthermore, project type introduced variability in project team performance.},
	keywords = {bug fixing, bugs, learning, Project performance, sourceforge, team size, teams, virtual organization},
	issn = {0378-7206},
	doi = {DOI: 10.1016/j.im.2008.09.004},
	url = {http://www.sciencedirect.com/science/article/B6VD0-4V1D7NT-1/2/a3bbf7652c674f753398160b8f05f6e9},
	author = {Yoris A. Au and Darrell Carpenter and Xiaogang Chen and Jan G. Clark}
}
@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}
}
@article {Xu2009151,
	title = {Volunteers{\textquoteright} involvement in online community based software development},
	journal = {Information \& Management},
	volume = {46},
	number = {3},
	year = {2009},
	note = {"Data were collected through an online survey and by searching project archives. On Sourceforge.net, each developer was uniquely identified with a user account, and the developer{\textquoteright}s performance was assessed through the number of function points accepted by the project in a certain time period, obtained through conversion and calculation from the project{\textquoteright}s code repository. Data for other constructs were obtained from the developers{\textquoteright} response to the online survey. "
"a developer{\textquoteright}s performance was measured by the number of function points made and accepted into the project during the observed time period."

project age, development status, license type, number of developers},
	pages = {151 - 158},
	abstract = {We sought to gain understanding of voluntary developers{\textquoteright} involvement in open source software (OSS) projects. Data were collected from voluntary developers working on open source projects. Our findings indicated that a voluntary developer{\textquoteright}s involvement was very important to his or her performance and that involvement was dependent on individual motivations (personal software needs, reputation and skills gaining expectation, enjoyment in open source coding) and project community factors (leadership effectiveness, interpersonal relationship, community ideology). Our work contributes theoretically and empirically to the body of OSS research and has practical implications for OSS project management.},
	keywords = {age, developers, effectiveness, function points, ideology, leadership, MOTIVATION, scm, sourceforge, status, Survey, team size, Volunteers},
	issn = {0378-7206},
	doi = {DOI: 10.1016/j.im.2008.12.005},
	url = {http://www.sciencedirect.com/science/article/B6VD0-4VP1CN0-1/2/8e1c7be4fcedd1419209c5c843ffa923},
	author = {Bo Xu and Donald R. Jones and Bingjia Shao}
}
@conference {1205,
	title = {Weaving~a~Semantic~Web~across~OSS~repositories: a~spotlight~on~bts-link,~UDD,~SWIM},
	booktitle = {4th Workshop on Public Data about Software Development (WoPDaSD 2009)},
	year = {2009},
	note = {position paper; non-experimental},
	abstract = {Several  public  repositories  and  archives  of  facts  about  libre software  projects,  developed either  by open  source  communities  or by research communities,  have been flourishing over  the Web in  the  recent  years.  These  enable  new analysis  and  support  new quality assurance tasks. 

By  using  Semantic  Web  techniques,  the  databases  containing data  about  open-source  software projects development can  be interconnected,  hence  letting  OSS  partakers  identify  resources, annotate  them  and  further  interlink  them  using  dedicated properties,  collectively  designing  a  distributed  semantic  graph. Such  links  expressed  with  standard  Semantic  techniques  are paving  the  way  to  new  applications  (including  ones  meant  for {\textquotedblleft}end-users{\textquotedblright}).  For  instance  this  may have  an  impact  on  the  way research efforts  are  conducted  (less  fragmented),  and  could  also be  used  by  development  communities  to  improve  Quality Assurance tasks. 

A goal  of the  research  conducted  within  the  HELIOS project, is to  address  bugtracker  synchronization  issues.  For that, the potential of using Semantic  Web  technologies  in  navigating between many different  bugtracker  systems scattered all  over the open source ecosystem is being investigated. 

This  position  paper  presents  some  existing  tools,  projects  and models  proposed  by  OSS  actors  that  are  complementary  to research  initiatives,  and  that  are  likely to  lead  to  useful  future  developments:  UDD (Ultimate  Debian  Database)  and  bts-link, developed by the  Debian community,  and  SWIM (Semantic Web enabled Issue Manager) developed by Mandriva. 

The  HELIOS team welcomes  comments  on the  future  paths  that  can  be  considered  in  using  the  Semantic  Web  approach  for improving these projects. },
	keywords = {bts-link, bug tracker, bugzilla, debian, ecosystem, helios, mandriva, semantic Web, swim, udd},
	attachments = {https://flosshub.org/sites/flosshub.org/files/HELIOS-WOPDASD-improved-Olivier.pdf},
	author = {Olivier Berger and Valentin Vlasceanu and Christian Bac and Lauri{\`e}re, St{\'e}phane}
}
@article {1338,
	title = {What Makes Free/Libre Open Source Software (FLOSS) Projects Successful? An Agent-Based Model of FLOSS Projects},
	journal = {International Journal of Open Source Software and Processes},
	volume = {1},
	year = {2009},
	pages = {1 - 13},
	abstract = {The last few years have seen a rapid increase in the number of Free/Libre Open Source Software (FLOSS) projects. Some of these projects, such as Linux and the Apache web server, have become phenomenally successful. However, for every successful FLOSS project there are dozens of FLOSS projects which never succeed. These projects fail to attract developers and/or consumers and, as a result, never get off the ground. The aim of this research is to better understand why some FLOSS projects flourish while others wither and die. This article presents a simple agent-based model that is calibrated on key patterns of data from SourceForge, the largest online site hosting open source projects. The calibrated model provides insight into the conditions necessary for FLOSS success and might be used for scenario analysis of future developments of FLOSS.},
	keywords = {Agent-Based Model, Emergent Properties, FLOSS, open source, Prediction Success, Simulation},
	issn = {1942-3934},
	doi = {10.4018/jossp.2009040101},
	url = {http://www.public.asu.edu/~majansse/pubs/ijossp09.pdf},
	attachments = {https://flosshub.org/sites/flosshub.org/files/ijossp09.pdf},
	author = {Radtke, Nicholas P. and Janssen, Marco A. and Collofello, James S.}
}
@conference {1208,
	title = {Advances in the Sourceforge Research Data Archive},
	booktitle = {3rd Workshop on Public Data about Software Development (WoPDaSD 2008)},
	year = {2008},
	month = {2009},
	pages = {25-29},
	abstract = {The SourceForge Research Data Archive (SRDA), located at http://zerlot.cse.nd.edu, is a collection of Open Source Software (OSS) data and resources [6]. Over 100 researchers worldwide use the archive for research in many fields. In this paper, we describe the recent changes, the work in progress, and future plans for making the archive easier to use and for allowing more advanced research to be done with the data available.},
	keywords = {forge, forges, repositories, repository, sourceforge, srda},
	attachments = {https://flosshub.org/sites/flosshub.org/files/srda2008.pdf},
	author = {Matthew Van Antwerp and Madey, Greg}
}
@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 {Hill:2008:AAM:1370750.1370771,
	title = {AMAP: automatically mining abbreviation expansions in programs to enhance software maintenance tools},
	booktitle = {Proceedings of the 2008 international working conference on Mining software repositories},
	series = {MSR {\textquoteright}08},
	year = {2008},
	month = {05/2008},
	pages = {79{\textendash}88},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {When writing software, developers often employ abbreviations in identifier names. In fact, some abbreviations may never occur with the expanded word, or occur more often in the code. However, most existing program comprehension and search tools do little to address the problem of abbreviations, and therefore may miss meaningful pieces of code or relationships between software artifacts. In this paper, we present an automated approach to mining abbreviation expansions from source code to enhance software maintenance tools that utilize natural language information. Our scoped approach uses contextual information at the method, program, and general software level to automatically select the most appropriate expansion for a given abbreviation. We evaluated our approach on a set of 250 potential abbreviations and found that our scoped approach provides a 57\% improvement in accuracy over the current state of the art.},
	keywords = {automatic abbreviation expansion, azureus, itext.net, liferay, maintenance, natural language, openoffice.org, program comprehension, source code, tiger envelopes, tools},
	isbn = {978-1-60558-024-1},
	doi = {http://doi.acm.org/10.1145/1370750.1370771},
	url = {http://doi.acm.org/10.1145/1370750.1370771},
	attachments = {https://flosshub.org/sites/flosshub.org/files/p79-hill.pdf},
	author = {Hill, Emily and Fry, Zachary P. and Boyd, Haley and Sridhara, Giriprasad and Novikova, Yana and Pollock, Lori and Vijay-Shanker, K.}
}
@conference {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 {1210,
	title = {Author Entropy: A Metric for Characterization  of Software Authorship Patterns},
	booktitle = {3rd Workshop on Public Data about Software Development (WoPDaSD 2008)},
	year = {2008},
	note = {used flossmole to get sample of SF developers},
	month = {2008},
	pages = {42-47},
	abstract = {We propose the concept of author entropy and describe how file-level entropy measures may be used to understand and characterize authorship patterns within individual files, as well as across an entire project. As a proof of concept, we compute author entropy for 28,955 files from 33 open-source projects. We explore patterns of author entropy, identify techniques for visualizing author entropy, and propose avenues for further study. },
	keywords = {developers, entropy, flossmole, sourceforge},
	attachments = {https://flosshub.org/sites/flosshub.org/files/entropy2008.pdf},
	author = {Taylor, Quinn C. and Stevenson, James E. and Delorey, Daniel P. and Knutson, Charles D.}
}
@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}
}
@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 {1207,
	title = {Cross-repository data linking with RDF and OWL},
	booktitle = {3rd Workshop on Public Data about Software Development (WoPDaSD 2008)},
	year = {2008},
	note = {non-experimental},
	month = {2009},
	pages = {15-22},
	abstract = {This paper provides an approach to the problem of integrating data from multiple research repositories for FLOSS 
data. It introduces semantic web technologies (RDF, OWL, OWL-DL reasoners and SPARQL) to argue that these are useful for building shared research infrastructure. The paper illustrates its point by describing parts of an ontology developed for the integration and analysis of project communications drawn from FLOSSmole, the Notre Dame archive and direct collection of data. RDF vocabularies provide a way to agree on things we agree about as well as a way to be clearer about ways in which we disagree.},
	keywords = {data integration, flossmole, forges, integration, owl, RDF, repositories, semantic, semantic Web, sparql, srda},
	attachments = {https://flosshub.org/sites/flosshub.org/files/howison2008.pdf},
	author = {Howison, James}
}
@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}
}
@article {1100,
	title = {An Empirical Study on the Relationship Between Software Design Quality, Development Effort and Governance in Open Source Projects},
	journal = {IEEE Transactions on Software Engineering},
	volume = {34},
	year = {2008},
	note = {"empirical data from a sample of 75 major OS projects"
no PDF to confirm [ms]},
	month = {11/2008},
	pages = {765 - 782},
	abstract = {The relationship among software design quality, development effort, and governance practices is a traditional research problem. However, the extent to which consolidated results on this relationship remain valid for open source (OS) projects is an open research problem. An emerging body of literature contrasts the view of open source as an alternative to proprietary software and explains that there exists a continuum between closed and open source projects. This paper hypothesizes that as projects approach the OS end of the continuum, governance becomes less formal. In turn a less formal governance is hypothesized to require a higher-quality code as a means to facilitate coordination among developers by making the structure of code explicit and facilitate quality by removing the pressure of deadlines from contributors. However, a less formal governance is also hypothesized to increase development effort due to a more cumbersome coordination overhead. The verification of research hypotheses is based on empirical data from a sample of 75 major OS projects. Empirical evidence supports our hypotheses and suggests that software quality, mainly measured as coupling and inheritance, does not increase development effort, but represents an important managerial variable to implement the more open governance approach that characterizes OS projects which, in turn, increases development effort.},
	keywords = {effort estimation, governance, quality, source code},
	issn = {0098-5589},
	doi = {10.1109/TSE.2008.68},
	author = {Capra, E. and Francalanci, C. and Merlo, F.}
}
@article {1091,
	title = {Evaluating the performance of open source software projects using data envelopment analysis},
	journal = {Information Management \& Computer Security},
	volume = {16},
	year = {2008},
	note = {"The data set used for this research consists of 34 OSS software projects listed on sourceforge.net." "only highly ranked projects in the security domain were considered."
"Ultimately data were collected on the 34 highest ranked security-based OSS software projects on Sourcefore.net."[sic]
fields: bug (?), developers, rank, downloads, Kperdownload (?)},
	month = {2008},
	pages = {449 - 462},
	abstract = {	

Purpose {\textendash} The purpose of this paper is to develop and test a model of the relative performance of open source software (OSS) projects.

Design/methodology/approach {\textendash} This paper evaluates the relative performance of OSS projects by evaluating multiple project inputs and multiple project outputs by using a data envelopment analysis (DEA) model. The DEA model produces an efficiency score for each project based on project inputs and outputs. The method of producing an efficiency score is based on the convex envelopment technology structure. The efficiency measure quantifies a {\textquotedblleft}distance{\textquotedblright} to an efficient frontier.

Findings {\textendash} The DEA model produced an index of corresponding intensities linking an inefficient project to its benchmark efficient project(s). The inefficiency measures produced an ordering of inefficient projects. Eight projects were found to be {\textquotedblleft}efficient{\textquotedblright} and used as benchmarking projects.

Research limitations/implications {\textendash} This research is limited to only security-based OSS projects. Future research on other areas of OSS projects is warranted.

Practical implications {\textendash} The result of this research is a practical model that can be used by OSS project developers to evaluate the relative performance of their projects and make resource decisions.

Originality/value {\textendash} This research extends the work of previous studies that have examined the relative performance of software development projects in a traditional development environment. As a result of this research, OSS projects can now be adequately benchmarked and evaluated according to project performance. An OSS project manger can effectively use these results to critically evaluate resources for their project and judge the relative efficiency of the resources.},
	keywords = {dea, efficiency, Project performance, sourceforge},
	issn = {0968-5227},
	doi = {10.1108/09685220810920530},
	author = {Wray, Barry and Mathieu, Richard and Teets, J.}
}
@conference {SGKL09,
	title = {Evaluating the Quality of Open Source Software},
	booktitle = {Electronic Notes in Theoretical Computer Science},
	volume = {233},
	year = {2008},
	note = {"the software source code and the associated data stored in the version control system, the bug tracking databases, the mailing lists, and the wikis allow us to evaluate quality in a transparent way"
"The data collection system collects the raw data from open source projects"
Mailing lists are measured in: Number of unique subscribers, Number of messages in user/support list per month, Number of messages in developers list per month, Average thread depth},
	month = {03/2009},
	pages = {5{\textendash}28},
	publisher = {The Reengineering Forum},
	organization = {The Reengineering Forum},
	abstract = {Traditionally, research on quality attributes was either kept under wraps within the organization that performed it, or carried out by outsiders using narrow, black-box techniques. The emergence of open source software has changed this picture allowing us to evaluate both software products and the processes that yield them. Thus, the software source code and the associated data stored in the version control system, the bug tracking databases, the mailing lists, and the wikis allow us to evaluate quality in a transparent way. Even better, the large number of (often competing) open source projects makes it possible to contrast the quality of comparable systems serving the same domain. Furthermore, by combining historical source code snapshots with significant events, such as bug discoveries and fixes, we can further dig into the causes and effects of problems. Here we present motivating examples, tools, and techniques that can be used to evaluate the quality of open source (and by extension also proprietary) software. },
	keywords = {bug tracking system, email, email archives, mailing list, metrics, open source, process quality attributes, product quality attributes, source code, SQO-OSS, wiki},
	doi = {10.1016/j.entcs.2009.02.058},
	url = {http://www.dmst.aueb.gr/dds/pubs/conf/2008-SQM-SQOOSS/html/SGKL09.html},
	attachments = {https://flosshub.org/sites/flosshub.org/files/entcs-sqooss.pdf},
	author = {Diomidis Spinellis and Gousios, Georgios and Vassilios Karakoidas and Panagiotis Louridas and Paul J. Adams and Samoladas, Ioannis and Ioannis Stamelos}
}
@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}
}
@conference {Hata:2008:EFF:1370750.1370772,
	title = {An extension of fault-prone filtering using precise training and a dynamic threshold},
	booktitle = {Proceedings of the 2008 international working conference on Mining software repositories},
	series = {MSR {\textquoteright}08},
	year = {2008},
	pages = {89{\textendash}98},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {Fault-prone module detection in source code is important for assurance of software quality. Most previous fault-prone detection approaches have been based on software metrics. Such approaches, however, have difficulties in collecting the metrics and in constructing mathematical models based on the metrics. To mitigate such difficulties, we have proposed a novel approach for detecting fault-prone modules using a spam-filtering technique, named Fault-Prone Filtering. In our approach, fault-prone modules are detected in such a way that the source code modules are considered as text files and are applied to the spam filter directly. In practice, we use the training only errors procedure and apply this procedure to fault-prone. Since no pre-training is required, this procedure can be applied to an actual development field immediately. This paper describes an extension of the training only errors procedures. We introduce a precise unit of training, "modified lines of code," instead of methods. In addition, we introduce the dynamic threshold for classification. The result of the experiment shows that our extension leads to twice the precision with about the same recall, and improves 15\% on the best F1 measurement.},
	keywords = {eclipse, fault-prone modules, spam filter, text mining},
	isbn = {978-1-60558-024-1},
	doi = {http://doi.acm.org/10.1145/1370750.1370772},
	url = {http://doi.acm.org/10.1145/1370750.1370772},
	attachments = {https://flosshub.org/sites/flosshub.org/files/p89-hata.pdf},
	author = {Hata, Hideaki and Mizuno, Osamu and Kikuno, Tohru}
}
@conference {972,
	title = {Extracting structural information from bug reports},
	booktitle = {Proceedings of the 2008 international workshop on Mining software repositories  - MSR {\textquoteright}08},
	year = {2008},
	month = {05/2008},
	pages = {27-30},
	publisher = {ACM Press},
	organization = {ACM Press},
	address = {New York, New York, USA},
	abstract = {In software engineering experiments, the description of bug reports is typically treated as natural language text, although it often contains stack traces, source code, and patches. Neglecting such structural elements is a loss of valuable information; structure usually leads to a better performance of machine learning approaches. In this paper, we present a tool called infoZilla that detects structural elements from bug reports with near perfect accuracy and allows us to extract them. We anticipate that infoZilla can be used to leverage data from bug reports at a different granularity level that can facilitate interesting research in the future.},
	keywords = {bug reports, eclipse, enumerations, infozilla, natural language, patches, source code, stack trace},
	isbn = {9781605580241},
	doi = {10.1145/1370750.1370757},
	attachments = {https://flosshub.org/sites/flosshub.org/files/p27-bettenburg.pdf},
	author = {Premraj, Rahul and Zimmermann, Thomas and Kim, Sunghun and Bettenburg, Nicolas}
}
@article {GonzalezBarahona2008356,
	title = {Geographic origin of libre software developers},
	journal = {Information Economics and Policy},
	volume = {20},
	number = {4},
	year = {2008},
	note = {Empirical Issues in Open Source Software},
	pages = {356 - 363},
	abstract = {This paper examines the claim that libre (free, open source) software involves global development. The anecdotal evidence is that developers usually work in teams including individuals residing in many different geographical areas, time zones and even continents and that, as a whole, the libre software community is also diverse in terms of national origin. However, its exact composition is difficult to capture, since there are few records of the geographical location of developers. Past studies have been based on surveying a limited (and sometimes biased) sample and extrapolating that sample to the global distribution of developers. In this paper we present an alternate approach in which databases are analyzed to create traces of information from which the geographical origin of developers can be inferred. Applying this technique to the SourceForge users database and the mailing lists archives from several large projects, we have estimated the geographical origin of more than one million individuals who are closely related to the libre software development process. The paper concludes that the result is a good proxy for the actual distribution of libre software developers working on global projects.},
	keywords = {developers, email, email address, email archives, geography, mailing list, open source software, sourceforge, timezone, users},
	issn = {0167-6245},
	doi = {DOI: 10.1016/j.infoecopol.2008.07.001},
	url = {http://www.sciencedirect.com/science/article/B6V8J-4T3DCPK-1/2/3981dfbc523eae1d1ce65fb1f0c0edb7},
	author = {Jesus M. Gonzalez-Barahona and Gregorio Robles and Roberto Andradas-Izquierdo and Rishab Aiyer Ghosh}
}
@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 {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 {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 {973,
	title = {On the relation of refactorings and software defect prediction},
	booktitle = {Proceedings of the 2008 international workshop on Mining software repositories  - MSR {\textquoteright}08},
	year = {2008},
	month = {05/2008},
	pages = {35-38},
	publisher = {ACM Press},
	organization = {ACM Press},
	address = {New York, New York, USA},
	abstract = {This paper analyzes the influence of evolution activities such as refactoring on software defects. In a case study of five open source projects we used attributes of software evolution to predict defects in time periods of six months. We use versioning and issue tracking systems to extract 110 data mining features, which are separated into refactoring and non-refactoring related features. These features are used as input into classification algorithms that create prediction models for software defects. We found out that refactoring related features as well as non-refactoring related features lead to high quality prediction models. Additionally, we discovered that refactorings and defects have an inverse correlation: The number of software defects decreases, if the number of refactorings increased in the preceding time period. As a result, refactoring should be a significant part of both bug fixes and other evolutionary changes to reduce software defects.},
	keywords = {argouml, bug fixing, bug reports, defects, evolution, jboss, liferay, prediction, refactoring, spring, weka, xdoclet},
	isbn = {9781605580241},
	doi = {10.1145/1370750.1370759},
	attachments = {https://flosshub.org/sites/flosshub.org/files/p35-ratzinger.pdf},
	author = {Sigmund, Thomas and Gall, Harald C. and Ratzinger, Jacek}
}
@article {1392,
	title = {Self-organization process in open-source software: An empirical study},
	journal = {Information and Software Technology},
	volume = {50},
	year = {2008},
	month = {4/2008},
	pages = {361 - 374},
	abstract = {Software systems must continually evolve to adapt to new functional requirements or quality requirements to remain competitive in the marketplace. However, different software systems follow different strategies to evolve, affecting both the release plan and the quality of these systems. In this paper, software evolution is considered as a self-organization process and the difference between closed-source software and open-source software is discussed in terms of self-organization. In particular, an empirical study of the evolution of Linux from version 2.4.0 to version 2.6.13 is reported. The study shows how open-source software systems self-organize to adapt to functional requirements and quality requirements.},
	keywords = {Empirical study;, evolution, linux, requirements, Self-organization, software evolution},
	issn = {09505849},
	doi = {10.1016/j.infsof.2007.02.018},
	url = {http://www.sciencedirect.com/science/article/pii/S0950584907000225},
	author = {Yu, Liguo}
}
@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 {Pattison:2008:TWP:1370750.1370776,
	title = {Talk and work: a preliminary report},
	booktitle = {Proceedings of the 2008 international working conference on Mining software repositories},
	series = {MSR {\textquoteright}08},
	year = {2008},
	month = {05/2008},
	pages = {113{\textendash}116},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {Developers in Open Source Software (OSS) projects communicate using mailing lists. By convention, the mailing lists used only for task-related discussions, so they are primarily concerned with the software under development, and software process issues (releases, etc.). We focus on the discussions concerning the software, and study the frequency with which software entities (functions, methods, classes, etc) are mentioned in the mail. We find a strong, striking, cumulative relationship between this mention count in the email, and the number of times these entities are included in changes to the software. When we study the same phenomena over a series of time-intervals, the relationship is much less strong. This suggests some interesting avenues for future research.},
	keywords = {ant, apache, email, mailing lists, postgresql, python, scm, source code},
	isbn = {978-1-60558-024-1},
	doi = {http://doi.acm.org/10.1145/1370750.1370776},
	url = {http://doi.acm.org/10.1145/1370750.1370776},
	attachments = {https://flosshub.org/sites/flosshub.org/files/p113-pattison.pdf},
	author = {Pattison, David S. and Bird, Christian A. and Premkumar T. Devanbu}
}
@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}
}
@conference {Hindle:2008:LCT:1370750.1370773,
	title = {What do large commits tell us?: a taxonomical study of large commits},
	booktitle = {Proceedings of the 2008 international working conference on Mining software repositories},
	series = {MSR {\textquoteright}08},
	year = {2008},
	month = {05/2008},
	pages = {99{\textendash}108},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {Research in the mining of software repositories has frequently ignored commits that include a large number of files (we call these large commits). The main goal of this paper is to understand the rationale behind large commits, and if there is anything we can learn from them. To address this goal we performed a case study that included the manual classification of large commits of nine open source projects. The contributions include a taxonomy of large commits, which are grouped according to their intention. We contrast large commits against small commits and show that large commits are more perfective while small commits are more corrective. These large commits provide us with a window on the development practices of maintenance teams.},
	keywords = {boost, bug fixing, egroupware, enlightenment, evolution, firebird, large commits, maintenance, mysql, postgresql, samba, software evolution, source control system, spring},
	isbn = {978-1-60558-024-1},
	doi = {http://doi.acm.org/10.1145/1370750.1370773},
	url = {http://doi.acm.org/10.1145/1370750.1370773},
	attachments = {https://flosshub.org/sites/flosshub.org/files/p99-hindle.pdf},
	author = {Hindle, Abram and Daniel M. German and Holt, Ric}
}
@conference {Pohl:2008:DNM:1370114.1370135,
	title = {What dynamic network metrics can tell us about developer roles},
	booktitle = {Proceedings of the 2008 international workshop on Cooperative and human aspects of software engineering (CHASE {\textquoteright}08)},
	series = {CHASE {\textquoteright}08},
	year = {2008},
	note = {paper d/l from http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.217.4765

this particular paper focuses on building the SNA using co-authorship of files in Tomcat.},
	pages = {81{\textendash}84},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {Software development is heavily dependent on the participants of the process and their roles within the process. Each developer has his specific skills and interests and hence contributes to the project in a different way. While some programmers work on separate modules, others developers integrate these modules towards the final product. To identify such different groups of people one approach is to work with methods taken from social network analysis. To this end, a social network has to be defined in a suitable way, and appropriate analysis strategies have to be chosen. This paper shows how a network of software developers could be defined based on information in a software repository, and what it can possibly tell about roles of developers (and what not) in the process of the application server Tomcat.},
	keywords = {identifying roles, social network analysis},
	isbn = {978-1-60558-039-5},
	doi = {10.1145/1370114.1370135},
	url = {http://doi.acm.org/10.1145/1370114.1370135},
	attachments = {https://flosshub.org/sites/flosshub.org/files/10.1.1.217.4765.pdf},
	author = {Pohl, Mathias and Diehl, Stephan}
}
@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 {1005,
	title = {Comparing Approaches to Mining Source Code for Call-Usage Patterns},
	booktitle = {Fourth International Workshop on Mining Software Repositories (MSR{\textquoteright}07:ICSE Workshops 2007)},
	year = {2007},
	pages = {20 - 20},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Minneapolis, MN, USA},
	abstract = {Two approaches for mining function-call usage patterns from source code are compared. The first approach, itemset mining, has recently been applied to this problem. The other approach, sequential-pattern mining, has not been previously applied to this problem. Here, a call-usage pattern is a composition of function calls that occur in a function definition. Both approaches look for frequently occurring patterns that represent standard usage of functions and identify possible errors. Itemset mining produces unordered patterns, i.e., sets of function calls, whereas, sequential-pattern mining produces partially ordered patterns, i.e., sequences of function calls. The trade-off between the additional ordering context given by sequential-pattern mining and the efficiency of itemset mining is investigated. The two approaches are applied to the Linux kernel v2.6.14 and results show that mining ordered patterns is worth the additional cost.},
	keywords = {function calls, functions, kernel, linux, sequence, sequencing, sequential-pattern mining},
	isbn = {0-7695-2950-X},
	doi = {10.1109/MSR.2007.3},
	attachments = {https://flosshub.org/sites/flosshub.org/files/28300020.pdf},
	author = {Kagdi, Huzefa and Collard, Michael L. and Maletic, Jonathan I.}
}
@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.}
}
@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 {992,
	title = {Determining Implementation Expertise from Bug Reports},
	booktitle = {Fourth International Workshop on Mining Software Repositories (MSR{\textquoteright}07:ICSE Workshops 2007)},
	year = {2007},
	pages = {2 - 2},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Minneapolis, MN, USA},
	abstract = {As developers work on a software product they accumulate expertise, including expertise about the code base of the software product. We call this type of expertise "implementation expertise". Knowing the set of developers who have implementation expertise for a software product has many important uses. This paper presents an empirical evaluation of two approaches to determining implementation expertise from the data in source and bug repositories. The expertise sets created by the approaches are compared to those provided by experts and evaluated using the measures of precision and recall. We found that both approaches are good at finding all of the appropriate developers, although they vary in how many false positives are returned.},
	keywords = {bug reports, developers, eclipse, expertise, repository, scm, source code},
	isbn = {0-7695-2950-X},
	doi = {10.1109/MSR.2007.7},
	attachments = {https://flosshub.org/sites/flosshub.org/files/28300002.pdf},
	author = {Anvik, John and Murphy, Gail C.}
}
@conference {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 {624,
	title = {Exploring the Effects of Coordination and Communication Tools on the Efficiency of Open Source Projects using Data Envelopment Analysis},
	booktitle = {OSS2007: Open Source Development, Adoption and Innovation (IFIP 2.13)},
	series = {IFIP International Federation for Information Processing },
	volume = {234/2007},
	year = {2007},
	note = {"based on the date january 8, 2007, we selected the 30 most often downloaded projects from Sourceforge.net"},
	month = {2007///},
	pages = {97 - 108},
	publisher = {Springer},
	organization = {Springer},
	chapter = {8},
	abstract = {In this paper, we propose to explore possible benefits of communication and coordination tools in open source projects using data envelopment analysis (DEA), a general method for efficiency comparisons. DEA offers several advantages: It is a non-parametric optimization method without any need for the user to define any relations between different factors or a production function, can account for economies or diseconwhile omies of scale, and is able to deal with multi-input, multi-output systems in which the factors have different scales. Using a data set of 30 open source project retrieved from SourceForge.net, we demonstrate the application of DEA, showing that the efficiency of the projects is in general relatively high. Regarding the effects of tool employment on the efficiency of projects, the results were surprising: Most of the possible tools, and overall usage, showed a negative relationship to efficiency.
},
	keywords = {metadata, sourceforge},
	issn = {978-0-387-72485-0},
	doi = {http://dx.doi.org/10.1007/978-0-387-72486-7_8},
	attachments = {https://flosshub.org/sites/flosshub.org/files/Exploring\%20the\%20Effects\%20Coodination.pdf},
	author = {Koch, Stefan}
}
@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}
}
@article {1416,
	title = {Identifying Success and Abandonment of Free/Libre and Open Source (FLOSS) Commons: A Preliminary Classification of Sourceforge.net projects},
	journal = {Upgrade: The European Journal for the Informatics Professional},
	volume = {VIII},
	year = {2007},
	pages = {54-59},
	abstract = {Free/Libre and Open Source Software (FLOSS) projects are a form of commons where individuals work collectively to produce software that is a public, rather than a private, good. The famous phrase {\textquotedblleft}Tragedy of the Commons{\textquotedblright} describes a situation where a natural resource commons, such as a pasture, or a water supply, gets depleted because of overuse. The tragedy in FLOSS commons is distinctly different: It occurs when collective action ceases before a software product is produced or reaches its full potential. This paper builds on previous work about defining success in FLOSS projects by taking a collective action perspective. We first report the results of interviews with FLOSS developers regarding our ideas about success and failure in FLOSS projects. Building on those interviews and previous work, we then describe our criteria for defining success/tragedy in FLOSS commons. Finally, we discuss the results of a preliminary classification of nearly all projects hosted on Sourceforge.net as of August 2006.},
	keywords = {flossmole, sourceforge, success},
	url = {http://www.cepis.org/upgrade/files/full-VI-07.pdf},
	author = {English, R. and Schweik, C. M.}
}
@article {hoepman2007increased,
	title = {Increased security through open source},
	journal = {Communications of the ACM},
	volume = {50},
	number = {1},
	year = {2007},
	pages = {79{\textendash}83},
	publisher = {ACM},
	abstract = {The last few years have shown a worldwide rise in the attention for, and
actual use of, open source software (OSS), most notably of the operating
system Linux and various applications running on top of it. Various major
companies and governments are adopting OSS. As a result, there are many
publications concerning its advantages and disadvantages. The ongoing discussions
cover a wide range of topics, such as Windows versus Linux, cost
issues, intellectual property rights, development methods, etc. Here we wish
to focus on security issues surrounding OSS. It has become a reasonably
well-established conviction within the computer security community that
publishing designs and protocols contributes to the security of systems built
on them. But should one go all the way and publish source code as well?
That is the fundamental question that we wish to address in this paper.},
	keywords = {security},
	url = {https://arxiv.org/pdf/0801.3924.pdf},
	attachments = {https://flosshub.org/sites/flosshub.org/files/0801.3924.pdf},
	author = {Hoepman, Jaap-Henk and Jacobs, Bart}
}
@article {126,
	title = {Investigating recognition-based performance in an open content community: A social capital perspective},
	journal = {Information \& Management},
	volume = {44},
	number = {3},
	year = {2007},
	note = {Times Cited: 0},
	month = {Apr},
	pages = {240-252},
	abstract = {As the open source movement grows, it becomes important to understand the dynamics that affect the motivation of participants who contribute their time freely to such projects. One important motivation that has been identified is the desire for formal recognition in the open source community. We investigated the impact of social capital in participants{\textquoteright} social networks on their recognition-based performance; i.e., the formal status they are accorded in the community. We used a sample of 465 active participants in the Wikipedia open content encyclopedia community to investigate the effects of two types of social capital and found that network closure, measured by direct and indirect ties, had a significant positive effect on increasing participants{\textquoteright} recognition-based performance. Structural holes had mixed effects on participants{\textquoteright} status, but were generally a source of social capital. (C) 2007 Elsevier B.V. All rights reserved.},
	keywords = {open content, recognition-based performance, social capital, social networks, social status, virtual communities},
	isbn = {0378-7206},
	author = {Okoli, C. and Oh, Wonseok}
}
@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 {999,
	title = {Mining Software Repositories with iSPAROL and a Software Evolution Ontology},
	booktitle = {Fourth International Workshop on Mining Software RepositoriesFourth International Workshop on Mining Software Repositories (MSR{\textquoteright}07:ICSE Workshops 2007)},
	year = {2007},
	pages = {10 - 10},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Minneapolis, MN, USA},
	abstract = {One of the most important decisions researchers face when analyzing the evolution of software systems is the choice of a proper data analysis/exchange format. Most existing formats have to be processed with special programs written specifically for that purpose and are not easily extendible. Most scientists, therefore, use their own database(s) requiring each of them to repeat the work of writing the import/export programs to their format.

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

The paper also shows iSPARQL -- our SPARQL-based Semantic Web query engine containing similarity joins. Together with EvoOnt, iSPARQL can accomplish a sizable number of tasks sought in software repository mining projects, such as an assessment of the amount of change between versions or the detection of bad code smells. To illustrate the usefulness of EvoOnt (and iSPARQL), we perform a series of experiments with a real-world Java project. These show that a number of software analyses can be reduced to simple iSPARQL queries on an EvoOnt dataset.},
	keywords = {database, eclipse, evoont, java, owl, semantic, sparql},
	isbn = {0-7695-2950-X},
	doi = {10.1109/MSR.2007.21},
	attachments = {https://flosshub.org/sites/flosshub.org/files/28300010.pdf},
	author = {Kiefer, Christoph and Bernstein, Abraham and Tappolet, Jonas}
}
@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 {1214,
	title = {A Preliminary Analysis of Publicly Available FLOSS Measurements: Towards Discovering Maintainability Trends},
	booktitle = {2nd Workshop on Public Data about Software Development (WoPDaSD 2007)},
	year = {2007},
	note = {used SourceKibitzer data downloaded from FLOSSmole},
	month = {2007},
	abstract = {The spread of free/libre/open source software (FLOSS) and the openness of its development model offer researchers a valuable source of information regarding software data. The creation of large portals, which host a vast amount of FLOSS projects make it easy to create large datasets with valuable information regarding the FLOSS development process. In addition initiatives such as FLOSSMole provide researchers with a single point and continuing access to those data. Up to now the majority of datasets from FLOSSMole offered data regarding the development process and not the code itself. From February 2007 FLOSSMole offers data donated 
by SourceKibitzer, which contain source code metrics for FLOSS projects written in Java. In this paper we provide 
a premilinary analysis on those data using machine learning techniques, such as classification rules and decision trees. Using the first available data from February 2007, we tried to build rules that can be used in order to estimate the future values of metrics offered for March. Here we present some preliminary results that are encouraging and deserve to be further analyzed in future releases of SourceKibitzer datasets. },
	keywords = {decision tree, flossmole, java, machine learning, metrics, sourcekibitzer},
	attachments = {https://flosshub.org/sites/flosshub.org/files/Samolades2007.pdf},
	author = {Samoladas, Ioannis and Bibi, Stamatia and Ioannis Stamelos and Sowe, Sulayman K. and Deligiannis, Ignatios}
}
@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 {1212,
	title = {Studying Production Phase SourceForge Projects: An Exploratory Analysis Using cvs2mysql and SFRA},
	booktitle = {2nd Workshop on Public Data about Software Development (WoPDaSD 2007)},
	year = {2007},
	month = {2007},
	abstract = {A wealth of data can be extracted from the natural by-products of software development processes and used in empirical studies of software engineering. However, the size and accuracy of such studies depend in large part on the availability of tools that facilitate the collection of data from individual projects and the combination of data from multiple projects. To demonstrate this point, we present our experience gathering and analyzing data from nearly 10,000 open source projects hosted on SourceForge. We describe the tools we developed to collect the data and the ways in which these tools and data may be used by other researchers. We also provide examples of statistics that we have calculated from these data to describe interesting author- and project-level behaviors of the SourceForge community.},
	keywords = {Data Collection, forge, repositories, sourceforge},
	attachments = {https://flosshub.org/sites/flosshub.org/files/Delorey2007c.pdf},
	author = {Delorey, Daniel P. and Knutson, Charles D. and MacLean, Alexander C.}
}
@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 {1010,
	title = {Using Software Repositories to Investigate Socio-technical Congruence in Development Projects},
	booktitle = {Fourth International Workshop on Mining Software Repositories (MSR{\textquoteright}07:ICSE Workshops 2007)},
	year = {2007},
	pages = {25 - 25},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Minneapolis, MN, USA},
	abstract = {We propose a quantitative measure of socio-technical congruence as an indicator of the performance of an organization in carrying out a software development project. We show how the information necessary to implement that measure can be mined from commonly used software repositories, and we describe how socio-technical congruence can be computed based on that information.},
	keywords = {developers, graph, scm, social networks, source code},
	isbn = {0-7695-2950-X},
	doi = {10.1109/MSR.2007.33},
	attachments = {https://flosshub.org/sites/flosshub.org/files/28300025.pdf},
	author = {Valetto, Giuseppe and Helander, Mary and Ehrlich, Kate and Chulani, Sunita and Wegman, Mark and Williams, Clay}
}
@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 {Herraiz:2006:CSN:1116163.1116405,
	title = {Comparison Between SLOCs and Number of Files As Size Metrics for Software Evolution Analysis},
	booktitle = {Proceedings of the Conference on Software Maintenance and Reengineering},
	series = {CSMR {\textquoteright}06},
	year = {2006},
	pages = {206{\textendash}213},
	publisher = {IEEE Computer Society},
	organization = {IEEE Computer Society},
	address = {Washington, DC, USA},
	keywords = {empirical studies, libre software, metrics, software evolution},
	isbn = {0-7695-2536-9},
	url = {http://dl.acm.org/citation.cfm?id=1116163.1116405},
	author = {Herraiz, Israel and Gregorio Robles and Gonzalez-Barahon, Jes us M.}
}
@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 {Amor:2006:EEC:1139113.1139116,
	title = {Effort Estimation by Characterizing Developer Activity},
	booktitle = {Proceedings of the 2006 International Workshop on Economics Driven Software Engineering Research},
	series = {EDSER {\textquoteright}06},
	year = {2006},
	pages = {3{\textendash}6},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {During the latest years libre (free, open source) software has gained a lot of attention from the industry. Following this interest, the research community is also studying it. For instance, many teams are performing quantitative analysis on the large quantity of data which is publicly available from the development repositories maintained by libre software projects. However, not much of this research is focused on cost or effort estimations, despite its importance (for instance, for companies developing libre software or collaborating with libre software projects), and the availability of some data which could be useful for this purpose. Our position is that classical effort estimation models can be improved from the study of these data, at least when applied to libre software. In this paper, we focus on the characterization of developer activity, which we argue can improve effort estimation. This activity can be traced with a lot of detail, and the resulting data can also be used for validation of any effort estimation model.
},
	keywords = {developer characterization, effort estimation, mining software repositories, open source software, software economics},
	isbn = {1-59593-396-4},
	doi = {10.1145/1139113.1139116},
	url = {http://doi.acm.org/10.1145/1139113.1139116},
	author = {Amor, Juan Jose and Gregorio Robles and Jesus M. Gonzalez-Barahona}
}
@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 {Robles:2006:GLD:1137983.1138017,
	title = {Geographic location of developers at SourceForge},
	booktitle = {Proceedings of the 2006 international workshop on Mining software repositories},
	series = {MSR {\textquoteright}06},
	year = {2006},
	pages = {144{\textendash}150},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {The development of libre (free/open source) software is usually performed by geographically distributed teams. Participation in most cases is voluntary, sometimes sporadic, and often not framed by a pre-defined management structure. This means that anybody can contribute, and in principle no national origin has advantages over others, except for the differences in availability and quality of Internet connections and language. However, differences in participation across regions do exist, although there are little studies about them. In this paper we present some data which can be the basis for some of those studies. We have taken the database of users registered at SourceForge, the largest libre software development web-based platform, and have inferred their geographical locations. For this, we have applied several techniques and heuristics on the available data (mainly e-mail addresses and time zones), which are presented and discussed in detail. The results show a snapshot of the regional distribution of SourceForge users, which may be a good proxy of the actual distribution of libre software developers. In addition, the methodology may be of interest for similar studies in other domains, when the available data is similar (as is the case of mailing lists related to software projects).},
	keywords = {distributed, email, email address, free software, geographical location, geography, libre software, mining software repositories, open source software, sourceforge, timezone},
	isbn = {1-59593-397-2},
	doi = {http://doi.acm.org/10.1145/1137983.1138017},
	url = {http://doi.acm.org/10.1145/1137983.1138017},
	attachments = {https://flosshub.org/sites/flosshub.org/files/144GeographicLocation.pdf},
	author = {Gregorio Robles and Jesus M. Gonzalez-Barahona}
}
@article {Crowston:2006a,
	title = {Hierarchy and centralization in Free and Open Source Software team communications},
	journal = {Knowledge, Technology \& Policy},
	volume = {18},
	number = {4},
	year = {2006},
	pages = {65{\textendash}85},
	abstract = {Free/Libre Open Source Software (FLOSS) development teams provide an interesting and convenient setting for studying distributed work. We begin by answering perhaps the most basic question: what is the social structure of these teams? Based on a social network analysis of interactions represented in 62,110 bug reports from 122 large and active projects, we find that some OSS teams are highly centralized, but contrary to expectation, others are not. Projects are mostly quite hierarchical on four measures of hierarchy, consistent with past research but contrary to the popular image of these projects. Furthermore, we find that the level of centralization is negatively correlated with project size, suggesting that larger projects become more modular. The paper makes a further methodological contribution by identifying appropriate analysis approaches for interaction data. We conclude by sketching directions for future research.},
	keywords = {apache, bug fixing, bug tracking, FLOSS, project success, savannah, social network analysis, sourceforge, team size, teams},
	attachments = {https://flosshub.org/sites/flosshub.org/files/CrowstonHierarchyAndCentralization.pdf},
	author = {Kevin Crowston and Howison, James}
}
@article {flosswp325,
	title = {Identifying Knowledge Brokers that Yield Software Engineering Knowledge in OSS Projects},
	journal = {Information and Software Technology},
	volume = {46},
	year = {2006},
	note = {Uses the Debian mailing lists "kde", "mentor", and "user". 
the collection period was from January 2001 to September 2004},
	month = {11/2006},
	pages = {1025-1033},
	abstract = {Much research on open source software development concentrates on developer lists and other software repositories to investigate what motivates professional software developers to participate in open source software projects. Little attention has been paid to individuals who spend valuable time in lists helping participants on some mundane yet vital project activities. Using three Debian lists as a case study we investigate the impact of knowledge brokers and their associated activities in open source projects. Social network analysis was used to visualize how participants are affiliated with the lists. The network topology reveals substantial community participation. The consequence of collaborating in mundane activities for the success of open source software projects is discussed. The direct beneficiaries of this research are in the identification of knowledge experts in open source software projects.},
	keywords = {debian, email, email archives, expertise, knowledge sharing, mailing list, project success, social network analysis},
	doi = {10.1016/j.infsof.2005.12.019},
	attachments = {https://flosshub.org/sites/flosshub.org/files/IST-Vol-48-11-2006.pdf},
	author = {Sowe, Sulayman K. and Ioannis Stamelos and Lefteris Angelis}
}
@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 {693,
	title = {Impact of Social Ties on Open Source Project Team Formation},
	booktitle = {OSS2006: Open Source Systems (IFIP 2.13)},
	series = {IFIP International Federation for Information Processing },
	volume = {203/2006},
	year = {2006},
	note = {"we randomly selected 1030 new projects that were registered between X and X in 2005. A web crawler downloaded the HTML files containing project summary data and developer information on the date of registration."},
	month = {2006///},
	pages = {307 - 317},
	publisher = {Springer},
	organization = {Springer},
	abstract = {In this paper, we empirically examined the role of social ties in OSSD team formation and developer joining behavior. We find that the existence and the amount of prior social relations in the network do increase the probability of an OSS project to attract more developers. Interestingly, for projects without preexisting social ties, developers tend to join the project initiated by people with less OSSD experience. This research fills a gap in the open source literature by conducting an empirical investigation of the role of social relations on project team formation behavior. Furthermore, the adoption of social network analysis, which has received little attention in the OSS literature, can yield some interesting results on the interactions among OSS developers.
},
	keywords = {developers, metadata, social network analysis, sourceforge},
	issn = {978-0-387-34225-2},
	doi = {http://dx.doi.org/10.1007/0-387-34226-5_31},
	attachments = {https://flosshub.org/sites/flosshub.org/files/Impact\%20of\%20Social\%20Ties\%20on\%20Open\%20Source\%20Project.pdf},
	author = {Hahn, Jungpil and Moon, Jae and Zhang, Chen}
}
@article {Crowston:2006,
	title = {Information systems success in Free and Open Source Software development: Theory and measures},
	journal = {Software Process{\textendash}Improvement and Practice},
	volume = {11},
	number = {2},
	year = {2006},
	note = {"we continue our examination of success measures using data from Sourceforge..."
"e chose the number of developers (assessed from the records of the project and from bug fixing logs), bug-fixing time, and popularity (assessed from the number of downloads and viewings of project Web pages, and inclusion in distributions). These measures were chosen because they span the reconsidered FLOSS development process discussed above, including inputs (number of developers), process (speed of bug fixing) and output (popularity)."},
	pages = {123{\textendash}148},
	abstract = {Information systems success is one of the most widely used dependent variables in information systems (IS) research, but research on Free/Libre and Open Source software (FLOSS) often fails to appropriately conceptualize this important concept. In this paper, we reconsider what success means within a FLOSS context. We first review existing models of IS success and success variables used in FLOSS research and assess them for their usefulness, practicality and fit to the FLOSS context. Then, drawing on a theoretical model of group effectiveness in the FLOSS development process, as well as an online discussion group with developers, we present additional concepts that are central to an appropriate understanding of success for FLOSS. In order to examine the practicality and validity of this conceptual scheme, the second half of our paper presents an empirical study that demonstrates its operationalization of the chosen measures and assesses their internal validity. We use data from SourceForge to measure the project{\textquoteright}s effectiveness in team building, the speed of the project at responding to bug reports and the project{\textquoteright}s popularity. We conclude by discussing the implications of this study for our proposed extension of IS success in the context of FLOSS development and highlight future directions for research.},
	keywords = {bug fixing, developers, downloads, FLOSS, flossmole, page views, popularity, project success, size, sourceforge, success, team size},
	doi = {10.1002/spip.259},
	attachments = {https://flosshub.org/sites/flosshub.org/files/CrowstonHowisonAnnabi2006.pdf},
	author = {Kevin Crowston and Howison, James and Hala Annabi}
}
@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 {Grewal:2006:LLL:1246148.1246155,
	title = {Location, Location, Location: How Network Embeddedness Affects Project Success in Open Source Systems},
	journal = {Management Science},
	volume = {52},
	number = {7},
	year = {2006},
	month = {July},
	pages = {1043{\textendash}1056},
	publisher = {INFORMS},
	address = {Institute for Operations Research and the Management Sciences (INFORMS), Linthicum, Maryland, USA},
	abstract = {The community-based model for software development in open source environments is becoming a viable alternative to traditional firm-based models. To better understand the workings of open source environments, we examine the effects of network embeddedness---or the nature of the relationship among projects and developers---on the success of open source projects. We find that considerable heterogeneity exists in the network embeddedness of open source projects and project managers. We use a visual representation of the affiliation network of projects and developers as well as a formal statistical analysis to demonstrate this heterogeneity and to investigate how these structures differ across projects and project managers. Our main results surround the effect of this differential network embeddedness on project success. We find that network embeddedness has strong and significant effects on both technical and commercial success, but that those effects are quite complex. We use latent class regression analysis to show that multiple regimes exist and that some of the effects of network embeddedness are positive under some regimes and negative under others. We use project age and number of page views to provide insights into the direction of the effect of network embeddedness on project success. Our findings show that different aspects of network embeddedness have powerful but subtle effects on project success and suggest that this is a rich environment for further study.},
	keywords = {affiliation network, age, developers, latent class analysis, network embeddedness, open source software, page views, perl, project success, registration, sourceforge},
	issn = {0025-1909},
	doi = {10.1287/mnsc.1060.0550},
	url = {http://portal.acm.org/citation.cfm?id=1246148.1246155},
	author = {Grewal, Rajdeep and Lilien, Gary L. and Mallapragada, Girish}
}
@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 {Xie:2006:MMA:1137983.1137997,
	title = {MAPO: mining API usages from open source repositories},
	booktitle = {Proceedings of the 2006 international workshop on Mining software repositories},
	series = {MSR {\textquoteright}06},
	year = {2006},
	pages = {54{\textendash}57},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {To improve software productivity, when constructing new software systems, developers often reuse existing class libraries or frameworks by invoking their APIs. Those APIs, however, are often complex and not well documented, posing barriers for developers to use them in new client code. To get familiar with how those APIs are used, developers may search the Web using a general search engine to find relevant documents or code examples. Developers can also use a source code search engine to search open source repositories for source files that use the same APIs. Nevertheless, the number of returned source files is often large. It is difficult for developers to learn API usages from a large number of returned results. In order to help developers understand API usages and write API client code more effectively, we have developed an API usage mining framework and its supporting tool called MAPO (for Mining API usages from Open source repositories). Given a query that describes a method, class, or package for an API, MAPO leverages the existing source code search engines to gather relevant source files and conducts data mining. The mining leads to a short list of frequent API usages for developers to inspect. MAPO currently consists of five components: a code search engine, a source code analyzer, a sequence preprocessor, a frequent sequence miner, and a frequent sequence post processor. We have examined the effectiveness of MAPO using a set of various queries. The preliminary results show that the framework is practical for providing informative and succinct API usage patterns.},
	keywords = {api, application programming interfaces, documentation, mining software repositories, pmd, program comprehension, search engine, sequences, source code, source code search engine},
	isbn = {1-59593-397-2},
	doi = {http://doi.acm.org/10.1145/1137983.1137997},
	url = {http://doi.acm.org/10.1145/1137983.1137997},
	attachments = {https://flosshub.org/sites/flosshub.org/files/54MAPO.pdf},
	author = {Xie, Tao and Pei, Jian}
}
@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 {Bird:2006:MES:1137983.1138033,
	title = {Mining email social networks in Postgres},
	booktitle = {Proceedings of the 2006 international workshop on Mining software repositories},
	series = {MSR {\textquoteright}06},
	year = {2006},
	pages = {185{\textendash}186},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {Open Source Software (OSS) projects provide a unique opportunity to gather and analyze publicly available historical data. The Postgres SQL server, for example, has over seven years of recorded development and communication activity. We mined data from both the source code repository and the mailing list archives to examine the relationship between communication and development in Postgres. Along the way, we had to deal with the difficult challenge of resolving email aliases. We used a number of social network analysis measures and statistical techniques to analyze this data. We present our findings in this paper.},
	keywords = {developers, email, email archives, open source, postgresql, scm, social network analysis, social networks, source code, status},
	isbn = {1-59593-397-2},
	doi = {http://doi.acm.org/10.1145/1137983.1138033},
	url = {http://doi.acm.org/10.1145/1137983.1138033},
	attachments = {https://flosshub.org/sites/flosshub.org/files/185MiningEmail.pdf},
	author = {Christian Bird and Gourley, Alex and Devanbu, Prem and Gertz, Michael and Swaminathan, Anand}
}
@conference {Robles:2006:MLS:1137983.1137986,
	title = {Mining large software compilations over time: another perspective of software evolution},
	booktitle = {Proceedings of the 2006 international workshop on Mining software repositories},
	series = {MSR {\textquoteright}06},
	year = {2006},
	pages = {3{\textendash}9},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {With the success of libre (free, open source) software, a new type of software compilation has become increasingly common. Such compilations, often referred to as {\textquoteright}distributions{\textquoteright}, group hundreds, if not thousands, of software applications and libraries written by independent parties into an integrated system. Software compilations raise a number of questions that have not been targeted so far by software evolution, which usually focuses on the evolution of single applications. Undoubtedly, the challenges that software compilations face differ from those found in single software applications. Nevertheless, it can be assumed that both, the evolution of applications and that of software compilations, have similarities and dependencies.In this sense, we identify a dichotomy, common to that in economics, of software evolution in the small (micro-evolution) and in the large (macro-evolution). The goal of this paper is to study the evolution of a large software compilation, mining the publicly available repository of a well-known Linux distribution, Debian. We will therefore investigate changes related to hundreds of millions of lines of code over seven years. The aspects that will be covered in this paper are size (in terms of number of packages and of number of lines of code), use of programming languages, maintenance of packages and file sizes.},
	keywords = {debian, distributions, evolution, large software collections, lines of code, loc, metrics, mining software repositories, size, sloc, sloccount, software evolution, software integrators},
	isbn = {1-59593-397-2},
	doi = {http://doi.acm.org/10.1145/1137983.1137986},
	url = {http://doi.acm.org/10.1145/1137983.1137986},
	attachments = {https://flosshub.org/sites/flosshub.org/files/3miningLarge.pdf},
	author = {Gregorio Robles and Jesus M. Gonzalez-Barahona and Martin Michlmayr and Amor, Juan Jose}
}
@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}
}
@article {895,
	title = {Multi-Modal Modeling, Analysis and Validation of Open Source Software Development Processes},
	journal = {Intern. J. Internet Technology and Web Engineering},
	volume = {1},
	number = {3},
	year = {2006},
	pages = {49-63},
	abstract = {Understanding the context, structure, activities, and content of software development processes found in practice has been and remains a challenging problem. In the world of free/open source software development, discovering and understanding what processes are used in particular projects is important in determining how they are similar to or different from those advocated by the software engineering community. Prior studies have revealed that development processes in F/OSSD projects are different in a number of ways. In this paper, we describe how a variety of modeling perspectives and techniques are used to elicit, analyze, and validate software development processes found in F/OSSD projects, with examples drawn from studies of the software requirements process found in the NetBeans.org project.},
	keywords = {empirical studies of software engineering, open source software development, process modeling, requirements processes, software process},
	attachments = {https://flosshub.org/sites/flosshub.org/files/Scacchi-Jensen-Noll-Elliott-OSSC05.pdf},
	author = {Walt Scacchi and Chris Jensen and Noll, J. and Elliott, M.}
}
@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 {703,
	title = {Participation in Free and Open Source Communities: An Empirical Study of Community Members{\textquoteright} Perceptions},
	booktitle = {OSS2006: Open Source Systems (IFIP 2.13)},
	series = {IFIP International Federation for Information Processing},
	year = {2006},
	pages = {221 - 231},
	publisher = {Springer},
	organization = {Springer},
	abstract = {Although the defining factors of Free and Open Source Software (FOSS) are generally seen as the availability and accessibility of the source code, it is what these facilitate that is perhaps of more significance. Source code availability allows the sharing of code, skills, knowledge, and effort, focused on a particular piece of software under development. The result of this is the FOSS community, which although often perceived as a single group, is actually many small groups, each bound by a common interest in a particular piece of software and using the Internet as a communication medium. Although there have been studies focusing on the motivation of FOSS developers to contribute to software, there has been little investigation into the motives, attitudes, and the culture within the communities as a whole. There is much more to most of these communities than software development. Many also have extensive support networks for the use of software, portals for research, and social facilities. This paper describes the results of an investigation into how FOSS community members perceive the communities that they belong to, their reasons for being in the community, and the manner in which they participate.
},
	keywords = {Survey},
	doi = {http://dx.doi.org/10.1007/0-387-34226-5_22},
	attachments = {https://flosshub.org/sites/flosshub.org/files/Participation\%20in\%20free\%20and\%20open\%20source.pdf},
	author = {Schofield, Andrew and Cooper, Grahame}
}
@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}
}
@article {1088,
	title = {Self-Organization Patterns in Wasp and Open Source Communities},
	journal = {IEEE Intelligent Systems},
	volume = {21},
	year = {2006},
	note = {"To investigate such claims, we studied an OSS community{\textquoteright}s social network from a dataset describing the email activity of 120 different software teams"
"Our test data originated from Sourceforge (http://sourceforge.net), a large open source project repository, and included communi- ties ranging from very small networks with one or two members to large networks with thousands of members."
"we limited our consideration to email traffic associated with bug fixes and bug reporting. As other researchers have shown[5] this email subset allows an effective reconstruction of the software community{\textquoteright}s social network."
"We thank Kevin Crowston and James Howison for making their software data publicly available."},
	month = {03/2006},
	pages = {36 - 40},
	abstract = {In this paper, we conducted a comparative study of how social organization takes place in a wasp colony and OSS developer communities. Both these systems display similar global organization patterns, such as hierarchies and clear labor divisions. As our analysis shows, both systems also define interacting agent networks with similar common features that reflect limited information sharing among agents. As far as we know, this is the first research study analyzing the patterns and functional significance of these systems{\textquoteright} weighted-interaction networks. By illuminating the extent to which self-organization is responsible for patterns such as hierarchical structure, we can gain insight into the origins of organization in OSS communities.},
	keywords = {agents, decentralization, developers, email, email archives, flossmole, hierarchy, labor division, organization, self-organizing teams, social network analysis, social networks, sourceforge, teams, wasps},
	issn = {1541-1672},
	doi = {10.1109/MIS.2006.34},
	url = {http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.95.5574\&rep=rep1\&type=pdf},
	attachments = {https://flosshub.org/sites/flosshub.org/files/valverde.pdf},
	author = {Valverde, S. and Theraulaz, G. and Gautrais, J. and Fourcassie, V. and Sole, R.V.}
}
@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 {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}
}
@conference {Kim:2005:ASC:1083142.1083154,
	title = {Analysis of signature change patterns},
	booktitle = {Proceedings of the 2005 international workshop on Mining software repositories},
	series = {MSR {\textquoteright}05},
	year = {2005},
	pages = {1{\textendash}5},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {Software continually changes due to performance improvements, new requirements, bug fixes, and adaptation to a changing operational environment. Common changes include modifications to data definitions, control flow, method/function signatures, and class/file relationships. Signature changes are notable because they require changes at all sites calling the modified function, and hence as a class they have more impact than other change kinds.We performed signature change analysis over software project histories to reveal multiple properties of signature changes, including their kind, frequency, and evolution patterns. These signature properties can be used to alleviate the impact of signature changes. In this paper we introduce a taxonomy of signature change kinds to categorize observed changes. We report multiple properties of signature changes based on an analysis of eight prominent open source projects including the Apache HTTP server, GCC, and Linux 2.5 kernel.},
	keywords = {apache, gcc, kernel, linux, signature change, signature change patterns, software evolution, software evolution path, soure code},
	isbn = {1-59593-123-6},
	doi = {http://doi.acm.org/10.1145/1082983.1083154},
	url = {http://doi.acm.org/10.1145/1082983.1083154},
	attachments = {https://flosshub.org/sites/flosshub.org/files/64AnalysisOfSignature.pdf},
	author = {Kim, Sunghun and Whitehead,Jr., E. James and Bevan, Jennifer}
}
@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 {Robles:2005:DIM:1083142.1083162,
	title = {Developer identification methods for integrated data from various sources},
	booktitle = {Proceedings of the 2005 international workshop on Mining software repositories},
	series = {MSR {\textquoteright}05},
	year = {2005},
	pages = {106-110},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {Studying a software project by mining data from a single repository has been a very active research field in software engineering during the last years. However, few efforts have been devoted to perform studies by integrating data from various repositories, with different kinds of information, which would, for instance, track the different activities of developers. One of the main problems of these multi-repository studies is the different identities that developers use when they interact with different tools in different contexts. This makes them appear as different entities when data is mined from different repositories (and in some cases, even from a single one). In this paper we propose an approach, based on the application of heuristics, to identify the many identities of developers in such cases, and a data structure for allowing both the anonymized distribution of information, and the tracking of identities for verification purposes. The methodology will be presented in general, and applied to the GNOME project as a case example. Privacy issues and partial merging with new data sources will also be considered and discussed.},
	keywords = {anonymization, bug tracker, developers, email, email address, gnome, identity, mailing list, privacy, source code, version control},
	isbn = {1-59593-123-6},
	doi = {http://doi.acm.org/10.1145/1082983.1083162},
	url = {http://doi.acm.org/10.1145/1082983.1083162},
	attachments = {https://flosshub.org/sites/flosshub.org/files/106DeveloperIdentification.pdf},
	author = {Gregorio Robles and Jesus M. Gonzalez-Barahona}
}
@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 {Liu:2005:ESE:1062455.1062566,
	title = {Enriching software engineering courses with service-learning projects and the open-source approach},
	booktitle = {Proceedings of the 27th international conference on Software engineering},
	series = {ICSE {\textquoteright}05},
	year = {2005},
	pages = {613{\textendash}614},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {Real-world software engineers deal with complex problem. Yet many software engineering courses do not involve projects of enough complexity to give students such experience. We sense that service-learning projects, while difficult to manage and sustain, can serve a crucial role in this regard. Through trials in a senior-level software engineering course, we discovered that the open-source approach works well to enable students to work on large, multiple-term service-learning projects. We developed GROw, a cross-term, cross-team educational software process to meet the challenges of adopting complex, real-world projects in one-term courses, and to sustain service learning.},
	keywords = {education, pedagogical, service learning, software engineering education},
	isbn = {1-58113-963-2},
	doi = {10.1145/1062455.1062566},
	url = {http://doi.acm.org/10.1145/1062455.1062566},
	author = {Liu, Chang}
}
@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}
}
@conference {786,
	title = {Future Development in the European Software Industry: Patentability of Computer Programs or Open Source Software?},
	booktitle = {OSS2005: Open Source Systems },
	year = {2005},
	pages = {311-313},
	abstract = {Economic literature has treated the patent system as an indispensable tool to incentive inventive activity and to foster diffusion of technological improvements, but recent developments have brought at the center of the stage the Open Source phenomenon which is based on completely different mechanisms among which the free disclosure of the inventive steps. This work analyzes changes that are taking place into patent literature in order to give account of the desirability of patents in software sector. In addition some ideas on empirical analysis are put forward: the possibility of measuring the relationship between patents and input of innovation process in the software sector and the influence that private firms will have on Open Source developers motivations.},
	keywords = {european, market segment, open source, os, patent, patent literature, patentability, software industry, software sector},
	url = {http://hdl.handle.net/2038/966},
	author = {Rentocchini, Francesco}
}
@proceedings {117,
	title = {A human capital perspective of organizational intention to adopt open source software},
	year = {2005},
	keywords = {Survey},
	author = {Yan Li and Chuan-Hoo Tan and Hock-Hai Teo and Alex Siow}
}
@conference {781,
	title = {Idealism and Commercialism {\textendash} Developing Free/Libre and Open Source Software in Private Businesses},
	booktitle = {OSS2005: Open Source Systems },
	year = {2005},
	pages = {301-302},
	abstract = {This paper presents a PhD research project undertaken as part of a larger project aimed at paying sociological attention to different forms of distribution of knowledge, including program code. We want to investigate empirically how the commons knows as free/open source software is actually made. In my PhD project I study the use and development of FLOSS in private businesses, focusing on professional developers working in private businesses and at the same time participating in the FLOSS community. The theoretical starting point is theories of power, dominance and legitimacy by Max Weber and Pierre Bourdieu.},
	keywords = {dominance, FLOSS, FLOSS community, free/libre, legitimacy, linux, open source, Private Businesses, social organisation, theories of power},
	url = {http://pascal.case.unibz.it/handle/2038/970},
	author = {Lundestad, Christian V.}
}
@conference {798,
	title = {An International Master Programme in Free Software in the European Higher Education Space},
	booktitle = {OSS2005: Open Source Systems },
	year = {2005},
	pages = {349-352},
	abstract = {The Universitat Oberta de Catalunya (Open University of Catalonia, UOC) offers an International Master programme in Free Software. The first edition of this master programme began on November 2003 and there are about 240 students currently enrolled at the different specialities offered by the program. In this paper, the design, the methodology and the first few conclusions drawn from this higher education experience are discussed and summarized. After this master programme was changed to accomplish with European Higher Education Space (EHES).},
	keywords = {education, free software, FS community, GNU/Linux, learning, master programme, software development, university},
	url = {http://pascal.case.unibz.it/handle/2038/713},
	author = {Meg{\'\i}as, David and Serra, Jordi and Macau, Rafael}
}
@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 {774,
	title = {Migrazione di un Sistema Informativo da UNIX-AIX a UNIX-Linux},
	booktitle = {OSS2005: Open Source Systems },
	year = {2005},
	pages = {287-288},
	abstract = {Il presente documento ha come obiettivo quello di descrivere la politica adottata dall{\textquoteright}Istituto Nazionale di Statistica rispetto all{\textquoteright}uso del software Open Source. In particolare vengono descritti i sistemi che attualmente operano su piattaforma Linux, quelli che sono in fase di migrazione e le scelte che si sono fatte nel caso di convivenza tra sistemi {\textquotedblleft}open{\textquotedblright} e sistemi {\textquotedblleft}proprietari{\textquotedblright}. Viene inoltre illustrata l{\textquoteright}architettura hardware scelta nel caso della migrazione di un sistema complesso da piattaforma interamente proprietaria (UNIX AIX) a piattaforma con sistema operativo open Linux Red Hat.},
	keywords = {architettura hardware, linux, migrazione, open source, server, sistema informativo, sistema proprietario, unix aix},
	url = {http://pascal.case.unibz.it/handle/2038/978},
	author = {Colasanti, Cecilia and Patruno, Vincenzo and Vaccari, Carlo}
}
@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}
}
@inbook {anderson2005open,
	title = {Open and Closed Systems are Equivalent (that is, in an ideal world)},
	booktitle = {Perspectives on free and open source software},
	year = {2005},
	pages = {127-142},
	publisher = {MIT Press},
	organization = {MIT Press},
	abstract = {...In May 2002, I proved a controversial theorem [8]: that, under the standard assumptions of reliability growth theory, it does not matter whether the system is open or closed. Opening a system enables the attacker to discover vulnerabilities more quickly, but it helps the defenders exactly as much.
This caused consternation in some circles, as it was interpreted as a general claim that open systems are no better than closed ones. But that is not what the theorem implies. Most real systems will deviate in important ways from the assumptions of the standard reliability growth model, and it will often be the case that open systems (or closed systems) will be better in some particular application. My theorem lets people concentrate on the differences between open and closed systems that matter in a particular case.},
	keywords = {security},
	isbn = {9780262062466},
	url = {http://www.cl.cam.ac.uk/~rja14/Papers/toulousebook.pdf},
	attachments = {https://flosshub.org/sites/flosshub.org/files/toulousebook.pdf},
	author = {Anderson, Ross}
}
@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 {Williams:2005:RSS:1083142.1083144,
	title = {Recovering system specific rules from software repositories},
	booktitle = {Proceedings of the 2005 international workshop on Mining software repositories},
	series = {MSR {\textquoteright}05},
	year = {2005},
	pages = {7-11},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {One of the most successful applications of static analysis based bug finding tools is to search the source code for violations of system-specific rules. These rules may describe how functions interact in the code, how data is to be validated or how an API is to be used. To apply these tools, the developer must encode a rule that must be followed in the source code. The difficulty is that many of these system-specific rules are undocumented and "grow" over time as the source code changes. Most research in this area relies on expert programmers to document these little-known rules. In this paper we discuss a method to automatically recover a subset of these rules, function usage patterns, by mining the software repository. We present a preliminary study that applies our work to a large open source software project.},
	keywords = {function usage patterns, functions, source code, wine},
	isbn = {1-59593-123-6},
	doi = {http://doi.acm.org/10.1145/1082983.1083144},
	url = {http://doi.acm.org/10.1145/1082983.1083144},
	attachments = {https://flosshub.org/sites/flosshub.org/files/7Recovering.pdf},
	author = {Williams, Chadd C. and Hollingsworth, Jeffrey K.}
}
@conference {794,
	title = {SchoolTool: Defining Our Niche in the Open Source Architecture of Schools},
	booktitle = {OSS2005: Open Source Systems },
	year = {2005},
	pages = {334-337},
	keywords = {information system, open source, school, student},
	url = {http://pascal.case.unibz.it/handle/2038/1436},
	author = {Hoffman, Tom}
}
@conference {Hindle:2005:SFM:1083142.1083161,
	title = {SCQL: a formal model and a query language for source control repositories},
	booktitle = {Proceedings of the 2005 international workshop on Mining software repositories},
	series = {MSR {\textquoteright}05},
	year = {2005},
	pages = {100-104},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {Source Control Repositories are used in most software projects to store revisions to source code files. These repositories operate at the file level and support multiple users. A generalized formal model of source control repositories is described herein. The model is a graph in which the different entities stored in the repository become vertices and their relationships become edges. We then define SCQL, a first order, and temporal logic based query language for source control repositories. We demonstrate how SCQL can be used to specify some questions and then evaluate them using the source control repositories of five different large software projects.},
	keywords = {evolution, file, gnumeric, modperl, openssl, revision, samba, scm, source code},
	isbn = {1-59593-123-6},
	doi = {http://doi.acm.org/10.1145/1082983.1083161},
	url = {http://doi.acm.org/10.1145/1082983.1083161},
	attachments = {https://flosshub.org/sites/flosshub.org/files/100scql.pdf},
	author = {Hindle, Abram and Daniel M. German}
}
@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}
}
@conference {717,
	title = {A Social Network Approach To Free/Open Source Software Simulation},
	booktitle = {OSS2005: Open Source Systems },
	year = {2005},
	note = {"Second, we use mailing list archives for three different projects. This gives us a more stringent network measure, since links are generated only when one developer communicates directly with another."
 
"The mailing lists were the developers list from a well deployed database server, the general list for an text and file processing library, and the general list for a smaller F/OSS web browser."},
	pages = {16-23},
	abstract = {Free and Open Source Software (F/OSS) development is a complex process that is just beginning to be understood. The actual development process is frequently characterized as disparate volunteer developers collaborating to create a piece of software. The developers of F/OSS, like most software engineers, spend a significant portion of their time fostering collaboration through various channels social communication. We have analyzed several methods of communication; a social networking site, project mailing lists, and developer weblogs; to gain an understanding of the social network structure behind F/OSS projects. This social network data was used to create a model of F/OSS development that allows for multiple projects, users, and developers with varying goals and socialization methods. Using this model we have been able to replicate some of the known phenomena observed in F/OSS and provide a first step in the creation of a robust model of F/OSS. },
	keywords = {email, mailing list, social network analysis},
	doi = {10.1.1.178.4984},
	url = {http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.178.4984},
	author = {Wagstrom, Patrick Adam and Herbsleb, James and Carley, Kathleen}
}
@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 {790,
	title = {	Socialization practices in FLOSS development teams},
	booktitle = {OSS2005: Open Source Systems },
	year = {2005},
	pages = {322-323},
	abstract = {Socialization of new members into Free/Libre Open Source Software (FLOSS) development teams is an important but little studied process in producing effective teams of this type. This is a dissertation proposal for a virtual ethnographic study that looks at the mechanisms and processes used to socialize new members into the team in order to help maintain a common group identity and focus.},
	keywords = {development team, FLOSS, member, open source, socialization},
	url = {http://pascal.case.unibz.it/handle/2038/1438},
	author = {Chengetai Masango}
}
@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 {899,
	title = {Stopping spyware at the gate: a user study of privacy, notice and spyware},
	booktitle = {2005 Symposium on Usable Privacy and Security},
	year = {2005},
	month = {07/2005},
	pages = {43-52},
	publisher = {Association for Computing Machinery},
	organization = {Association for Computing Machinery},
	address = {Pittsburgh, PA},
	keywords = {agreement,, and, Aspects,, Design,, end, EULA,, Experimentation,, Factors,, Human, Legal, license, notice,, of, privacy,, security, service,, spyware,, terms, ToS,, usability,, user},
	isbn = {1-59593-178-3 },
	author = {N. Good and Dhamija, R. and J. Grossklags and D. Thaw and Aronowitz, S. and D. Mulligan and J. Konstan}
}
@conference {788,
	title = {Structure, Cohesion, and Open Source Software Success},
	booktitle = {OSS2005: Open Source Systems },
	year = {2005},
	pages = {317-319},
	abstract = {This paper proposes a dissertation designed to understand how the open source software (OSS) development group and its associated interest community jointly and independently impact OSS success for a single OSS project.},
	keywords = {interest community, network externalities, open source software, software quality},
	url = {http://pascal.case.unibz.it/handle/2038/1536},
	author = {Sherae Daniel}
}
@article {swire2005theory,
	title = {A Theory of Disclosure for Security and Competitive Reasons: Open Source, Proprietary Software, and Government Systems},
	journal = {Hous. L. Rev.},
	volume = {42},
	year = {2005},
	pages = {1333},
	publisher = {HeinOnline},
	abstract = {A previous article, {\textquotedblleft}A Model for When Disclosure Helps Security: What is
Different about Computer and Network Security?{\textquotedblright} proposed a model for
when disclosure helps or hurts security and provided reasons why computer
security is often different in this respect than physical security.
 This chapter provides a general approach for describing the incentives of actors to
disclose information about their software or systems. A chief point of this
chapter is that the incentives of disclosure depend on two largely independent
assessments: (i) the degree to which disclosure helps or hurts security},
	keywords = {security},
	attachments = {https://flosshub.org/sites/flosshub.org/files/KP21\%2003\%20Swire.pdf},
	author = {Swire, Peter P}
}
@conference {797,
	title = {Transfering Libre Software Development Practices to the Production of Educational Resources: the Edukalibre Project},
	booktitle = {OSS2005: Open Source Systems },
	year = {2005},
	pages = {341-348},
	abstract = {The transfer of methodologies common in libre (free, open source) sofware development to the domain of educational resources can radically change the way educational content is developed and used, enabling both educational practitioners and students to become actively involved in its creation and distribution. New software architectures and tools are needed to effectively support this process. This paper describes a platform aimed to support the creation of free, collaboratively constructed educational content on the web, which has been developed within the Edukalibre project. It provides easy access to core technologies: a control version system combined with conversion tools to produce several convenient formats for each document. Its modular architecture offers many different interfaces to the users. The Edukalibre platform is distributed as libre software.},
	keywords = {educational resources, information systems, open source, software development practices},
	url = {http://pascal.case.unibz.it/handle/2038/1548},
	author = {Gonz{\'a}lez-Barahona, Jes{\'u}s M. and Chris Tebb and Vania Dimitrova and Chaparro, Diego and Romera, Teo}
}
@conference {Neamtiu:2005:USC:1083142.1083143,
	title = {Understanding source code evolution using abstract syntax tree matching},
	booktitle = {Proceedings of the 2005 international workshop on Mining software repositories},
	series = {MSR {\textquoteright}05},
	year = {2005},
	pages = {2-6},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {Mining software repositories at the source code level can provide a greater understanding of how software evolves. We present a tool for quickly comparing the source code of different versions of a C program. The approach is based on partial abstract syntax tree matching, and can track simple changes to global variables, types and functions. These changes can characterize aspects of software evolution useful for answering higher level questions. In particular, we consider how they could be used to inform the design of a dynamic software updating system. We report results based on measurements of various versions of popular open source programs, including BIND, OpenSSH, Apache, Vsftpd and the Linux kernel.},
	keywords = {abstract syntax trees, apache, bind, evolution, linux, openssh, software evolution, source code, source code analysis, vsftpd},
	isbn = {1-59593-123-6},
	doi = {http://doi.acm.org/10.1145/1082983.1083143},
	url = {http://doi.acm.org/10.1145/1082983.1083143},
	attachments = {https://flosshub.org/sites/flosshub.org/files/2Understanding.pdf},
	author = {Neamtiu, Iulian and Foster, Jeffrey S. and Hicks, Michael}
}
@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}
}
@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 {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 {1185,
	title = {Contributing to OS Projects. A Comparison between Individual and Firms},
	year = {2004},
	note = {"Following the approach used in previous surveys on Open Source developers, we prepared an on-line questionnaire;"},
	pages = {18-22},
	abstract = {This paper studies the contributions software firms make to Open Source (OS) projects. Our goal is to ascertain whether they follow the same regularity of pattern seen for individual programmer An exhaustive empirical analysis was carried out using data on project membership1 , project coordination and the contributions made by 146 Italian firms that do business with OS software. We compare our findings with the results of the surveys taken on OS programmers. The availability of the data gathered by Hertel et al. ([10]) on 141 developers of the Linux kernel allowed a direct comparison to be carried out between the two sets2 .},
	keywords = {Survey},
	attachments = {https://flosshub.org/sites/flosshub.org/files/19-23.pdf},
	author = {Andrea Bonaccorsi and Cristina Rossi}
}
@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 {77,
	title = {Do the Rich Get Richer? The Impact of Power Laws on Open Source Development Projects},
	booktitle = {2004 Open Source Conference (OSCON)},
	year = {2004},
	type = {conference presentation},
	address = {Portland, OR, USA},
	keywords = {open source, power law, social network analysis, sourceforge},
	author = {Conklin, Megan}
}
@conference {Xinyi04fourinteresting,
	title = {Four Interesting Ways in Which History Can Teach Us About Software},
	booktitle = {Proceedings of the 2004 international workshop on Mining software repositories  - MSR {\textquoteright}04},
	year = {2004},
	month = {05/2004},
	pages = {58-62},
	abstract = {In this position paper, we outline four kinds of studies that we have undertaken in trying to understand various aspects of a software system{\textquoteright}s evolutionary history. In each instance, the studies have involved detailed examination of real software systems based on {\textquotedblleft}facts{\textquotedblright} extracted from various kinds of source artifact repositories, as well as the development of accompanying tools to aid in the extraction, abstraction, and comprehension processes. We briefly discuss the goals, results, and methodology of each approach.},
	keywords = {ant, apache, change analysis, clone, clone detection, cvs, evolution, gcc, growth, kepler, linux, midworld, mycore, postgresql, source code, version control},
	attachments = {https://flosshub.org/sites/flosshub.org/files/58FourInterestingWays.pdf},
	author = {Michael Godfrey and Xinyi Dong and Cory Kapser and Lijie Zou}
}
@conference {1105,
	title = {Free \& Open Source Software Creation and {\textquoteleft}the Economy of Regard{\textquoteright}},
	booktitle = {Third EPIP Workshop},
	year = {2004},
	month = {04/2004},
	keywords = {linux, linux kernel, scm, source code},
	attachments = {https://flosshub.org/sites/flosshub.org/files/DalleDavidGhosh\%20Wolak.pdf},
	author = {Jean-Michel Dalle and Paul A. David and Rishab Ayer Ghosh and Frank A. Wolak}
}
@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}
}
@proceedings {1194,
	title = {Inside an Open Source Software Community: Empirical Analysis on Individual and Group Level},
	year = {2004},
	pages = {65-70},
	abstract = {An established Open Source Software community (Apache Cocoon) was explored using an online questionnaire about demographic data and individual and	group-related	factors.	Individual	factors encompassed forms of contributions, motivation, expertise and knowledge. Role structures, expectations towards other members, trust and collaboration issues were analysed at group level. More than 60\% of the developer community completed this questionnaire. Results provide a valuable basis for deeper understanding of knowledge sharing, collaboration and innovation processes in distributed work groups.},
	keywords = {apache, Survey},
	attachments = {https://flosshub.org/sites/flosshub.org/files/maass66-71.pdf},
	author = {Maass, W.}
}
@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}
}
@proceedings {124,
	title = {Membership dynamics and network stability in the open-source community: the ising perspective},
	year = {2004},
	note = {"simulations with the empirical network data that were collected from two actual OSS communities, Linux and Hypermail."

"we initially downloaded nearly 100,000 archived (between 1997 and 2003) LINUX Kernel and Hypermail newsgroup messages posted in a UNIX mailbox format"

"Specific information was obtained regarding the characteristics of these two OSS communities, including the size, the number of average connections per participant, and the hierarchy of each community."},
	abstract = {In this paper, we address the following two questions: (1)How does a participant{\textquoteright}s membership decision affect the others (neighbors) with whom he has collaborated over an extended period of time in an open source software (OSS) network? (2) To what extent do network characteristics (i.e, size and connectivity) mediate the impact of external factors on the OSS participants{\textquoteright} dynamic membership decisions and hence the stability of the network? From the Ising perspective, we present fresh theoretical insight into the dynamic and reciprocal membership relations between OSS participants. We also performed simulations based on empirical data that were collected from two actual OSS communities. Some of the key findings include that (1) membership herding is highly present when the external force is weak, but decreases significantly when the force increases, (2) the propensity for membership herding is most likely to be seen in a large network with a random connectivity, and (3) for large networks, at low external force a random connectivity will perform better than a scale-free counterpart in terms of the network strength. However, as the temperature (external force) increases, the reverse phenomenon is observed. In addition, the scale-free connectivity appears to be less volatile than with the random connectivity in response to the increase in the temperature. We conclude with several implications that may be of significance to OSS stakeholders.},
	keywords = {email, email archive, hypermail, linux, mailing list, membership, membership herding, newsgroup, open source, participants, social network analysis, stakeholders, team size},
	attachments = {https://flosshub.org/sites/flosshub.org/files/OhJeon.pdf},
	author = {Oh, Wonseok and Jeon, Sangyong}
}
@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}
}
@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.}
}
@proceedings {flosswp181,
	title = {The perils and pitfalls of mining SourceForge},
	year = {2004},
	month = {05/2004},
	pages = {7-11},
	abstract = {SourceForge provides abundant accessible data from Open Source Software development projects, making it an attractive data source for software engineering research. However it is not without theoretical peril and practical pitfalls. In this paper, we outline practical lessons gained from our spidering, parsing and analysis of SourceForge data. SourceForge can be practically difficult: projects are defunct, data from earlier systems has been dumped in and crucial data is hosted outside SourceForge, dirtying the retrieved data. These practical issues play directly into analysis: decisions made in screening projects can reduce the range of variables, skewing data and biasing correlations. SourceForge is theoretically perilous: because it provides easily accessible data items for each project, tempting researchers to fit their theories to these limited data. Worse, few are plausible dependent variables. Studies are thus likely to test the same hypotheses even if they start from different theoretical bases. To avoid these problems, analyses of SourceForge projects should go beyond project level variables and carefully consider which variables are used for screening projects and which for testing hypotheses.},
	keywords = {Data Collection, sourceforge},
	attachments = {https://flosshub.org/sites/flosshub.org/files/howison04msr.pdf},
	author = {Howison, James and Kevin Crowston}
}
@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}
}
@conference {flosswp180,
	title = {Towards a Portfolio of FLOSS project Success Measures},
	booktitle = {Workshop on Open Source Software Engineering, International Conference on Software Engineering},
	year = {2004},
	month = {May},
	abstract = {Project success is one of the most widely used dependent variables in information systems research. However, conventional measures of project success are difficult to apply to Free/Libre Open Source Software projects. In this paper, we present an analysis of four measures of success applied to SourceForge projects: number of members of the extended development community, project activity, bug fixing time and number of downloads. We argue that these four measures provide different insights into the collaboration and control mechanisms of the projects.},
	keywords = {bug fixing, developers, downloads, project success, sourceforge, team, team size},
	attachments = {https://flosshub.org/sites/flosshub.org/files/crowston04towards.pdf},
	author = {Kevin Crowston and Hala Annabi and Howison, James and Chengetai Masango}
}
@proceedings {103,
	title = {Why developers participate in open source software projects: an empirical investigation},
	year = {2004},
	keywords = {Survey},
	author = {Il-Horn Hann and Jeff Roberts and Sandra Slaughter}
}
@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}
}
@article {flosswp84,
	title = {Clustering and Dependencies in Free/Open Source Software Development: Methodology and Tools},
	year = {2003},
	note = {source code is the artifact used},
	month = {April},
	abstract = {This paper addresses the problem of measurement of non-monetary economic activity, specifically in the area of free/open source software communities. It describes the problems associated with research on these communities in the absence of measurable monetary transactions, and suggests possible alternatives. A class of techniques using software source code as factual documentation of economic activity is described and a methodology for the extraction, interpretation and analysis of empirical data from software source code is detailed, with the outline of algorithms for identifying collaborative authorship and determining the identity of coherent economic actors in developer communities. Finally, conclusions are drawn from the application of these techniques to a base of software.},
	keywords = {scm, source code, source code analysis},
	url = {http://dxm.org/papers/toulouse2/cluster-final.pdf},
	attachments = {https://flosshub.org/sites/flosshub.org/files/cluster-final.pdf},
	author = {Rishab Ayer Ghosh}
}
@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}
}
@article {flosswp103,
	title = {Contributing to the common pool resources in Open Source software. A comparison between individuals and firms},
	year = {2003},
	month = {August},
	abstract = {This paper studies the contributions to Open Source projects of software firms. Our goal is to analyse whether they follow the same regularities that characterize the behaviour of individual programmers. An exhaustive empirical analysis is carried out using data on project membership, project coordination and contribution efforts of 146 Italian firms that do business with Open Source software. We follow a meta-analytic approach comparing our findings with the results of the surveys conducted on Free Software programmers. Moreover, the availability of the data gathered by Hertel et al. (2003) on 141 developers of the Linux kernel will allow direct comparisons between the two sets.},
	keywords = {developers, linux, linux kernel, Survey},
	attachments = {https://flosshub.org/sites/flosshub.org/files/bnaccorsirossidevelopers.pdf},
	author = {Andrea Bonaccorsi}
}
@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 {116,
	title = {How open source software works: "free" user-to-user assistance},
	journal = {Research Policy},
	volume = {32},
	number = {6},
	year = {2003},
	note = {"The empirical data we collected for study was related to postings to the Apache Usenet help forum, CIWS-U (comp.infosystems.www.servers.unix). "
"For data regarding long-term participation in CIWS-U{\textemdash}who participated, long-term trends, etc.{\textemdash}we examined Usenet posting patterns from 1996 to 1999."
"The Usenet log data was obtained from a World Wide Web service called Deja.com (since acquired by Google)"
survey},
	pages = {923-943},
	abstract = {Research into free and open source software development projects has so far largely focused on how the major tasks of software development are organized and motivated. But a complete project requires the execution of "mundane but necessary" tasks as well. In this paper, we explore how the mundane but necessary task of field support is organized in the case of Apache web server software, and why some project participants are motivated to provide this service gratis to others. We find that the Apache field support system functions effectively. We also find that, when we partition the help system into its component tasks, 98\% of the effort expended by information providers in fact returns direct learning benefits to those providers. This finding considerably reduces the puzzle of why information providers are willing to perform this task "for free." Implications are discussed.},
	keywords = {apache, help, logs, MOTIVATION, participants, Survey, usenet},
	doi = {http://dx.doi.org/10.1016/S0048-7333(02)00095-1},
	url = {http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.110.8172\&rep=rep1\&type=pdf},
	attachments = {https://flosshub.org/sites/flosshub.org/files/lakhani2003.pdf},
	author = {Karim R Lakhani and von Hippel, Eric}
}
@article {flosswp85,
	title = {An Introduction to Open Source Communities},
	year = {2003},
	month = {04/2003},
	institution = {Blue Oxen Associates},
	abstract = {This report describes what open source communities are and how they work. It cites relevant research and presents original case studies of two open source projects: TouchGraph and SquirrelMail. It then identifies patterns of collaboration shared by these projects, and describes how these patterns might apply to other types of communities. Finally, it reviews what is still not well understood about open source communities, and proposes several paths for further research.},
	keywords = {free software foundation directory, freshmeat, fsf, sourceforge, squirrelmail, touchgraph},
	attachments = {https://flosshub.org/sites/flosshub.org/files/blueoxen.pdf},
	author = {Eugene Eric Kim}
}
@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 {flosswp122,
	title = {Managing the Boundary of an {\textquoteright}Open{\textquoteright} Project},
	year = {2003},
	month = {October},
	abstract = {In the past ten years, the boundaries between public and open science and commercial research efforts have become more porous. Scholars have thus more critically examined ways in which these two institutional regimes intersect. Large open source software projects have also attracted commercial collaborators and now struggle to develop code in an open public environment that still protects their communal boundaries. This research applies a dynamic social network approach to understand how one community managed software project, Debian, develops a membership process. We examine the project{\textquoteright}s face-to-face social network during a five-year period (1997-2001) to see how changes in the social structure affect the evolution of membership mechanisms and the determination of gatekeepers. While the amount and importance of a contributor{\textquoteright}s work increases the probability that a contributor will become a gatekeeper, those more central in the social network are more likely to become gatekeepers and influence the membership process. A greater understanding of the mechanisms open projects use to manage their boundaries has critical implications for research and knowledge producing communities operating in pluralistic, open and distributed environments.},
	keywords = {debian, membership, social network analysis},
	attachments = {https://flosshub.org/sites/flosshub.org/files/omahonyferraro.pdf},
	author = {Siobhan O{\textquoteright}Mahony}
}
@conference {DBLP:conf/pakdd/ChawlaAD03,
	title = {Mining Open Source Software (OSS) Data Using Association Rules Network},
	booktitle = {Lecture Notes in Computer Science },
	volume = {2637},
	year = {2003},
	pages = {461-466},
	abstract = {The Open Source Software(OSS) movement has attracted considerable attention in the last few years. In this paper we report our results of mining data acquired from SourceForge.net, the largest open source software hosting website. In the process we introduce Association Rules Network(ARN), a (hyper)graphical model to represent a special class of association rules. Using ARNs we discover important relationships between the attributes of successful OSS projects. We verify and validate these relationships using Factor Analysis, a classical statistical technique related to Singular Value Decomposition(SVD).},
	keywords = {arn, association rules, factor analysis, project success, sourceforge, svd},
	author = {Sanjay Chawla and Bavani Arunasalam and Joseph G. Davis}
}
@article {123,
	title = {Open source software development and Lotka{\textquoteright}s Law: Bibliometric patterns in programming},
	journal = {Journal of the American Society for Information Science and Technology},
	volume = {54},
	number = {2},
	year = {2003},
	note = {"Two lead- ing metadata repositories are the Linux Software Map (LSM) and Sourceforge, both of which were used for this research."
"For this article, we examined data listing the number of registered developers for each software project hosted by Sourceforge."
"The data we obtained from the LSM collection were taken mainly from the Author: field of LSM records. The Author: field in LSM records gives us the ability to track the author of record for a software package. LSM metadata also include a list of maintainers, primary software distribution sites, date of update and other items."
"The data we obtained from Sourceforge consist of a list of developer ID numbers, followed by the number of projects on which the individual is listed as a developer, then the number of projects on which the individual is listed as an administrator. These data were provided for all 33,892 individuals registered to work on projects hosted by Sourceforge in July 2001."},
	pages = {169-178},
	abstract = {This research applies Lotka{\textquoteright}s Law to metadata on open source software development. Lotka{\textquoteright}s Law predicts the proportion of authors at different levels of productivity. Open source software development harnesses the creativity of thousands of programmers worldwide, is important to the progress of the Internet and many other computing environments, and yet has not been widely researched. We examine metadata from the Linux Software Map (LSM), which documents many open source projects, and Sourceforge, one of the largest resources for open source developers. Authoring patterns found are comparable to prior studies of Lotka{\textquoteright}s Law for scientific and scholarly publishing. Lotka{\textquoteright}s Law was found to be effective in understanding software development productivity patterns, and offer promise in predicting aggregate behavior of open source developers.},
	keywords = {developers, linux, linux software map, lsm, sourceforge, team size},
	doi = {10.1002/asi.10177},
	author = {Newby, G. B. and Greenberg, J. and Jones, P.}
}
@conference {Wynn03organizationalstructure,
	title = {Organizational Structure of Open Source Projects: A Life Cycle Approach},
	booktitle = {Proceedings of 7th Annual Conference of the Southern Association for Information Systems},
	year = {2003},
	note = {"The three graphs in Figure 2 below were taken from smoothed download counts for existing open source projects on Sourceforge.net"
"A random sample of 150 open source projects will be taken from data provided by Sourceforge.net. Each project will be evaluated to determine their current life cycle stage (where possible) using download counts. Next, the project admins, developers, and several identifiable users for each evaluated project will be contacted via email to request completing a brief questionnaire to measure the current focus of the project, formal structure, division of labor, leader role, coordination, level of commitment, user success, and developer success. "},
	abstract = {The structure of open source project communities is discussed in relation to the organizational life cycle. In lieu of sales figures, the download counts for each project are used to identify the life cycle stage of a random sample of open source projects. A research model is proposed that attempts to measure the fit between the life cycle stage and the specific organizational characteristics of these projects (focus, division of labor, role of the leader, level of commitment, and coordination/control) as an indicator of the success of a project as measured by the satisfaction and involvement of both developers and users.},
	keywords = {division of labor, downloads, growth, interview, leadership, life cycle, lifecycle, project success, roles, sourceforge, Survey},
	attachments = {https://flosshub.org/sites/flosshub.org/files/wynn2004.pdf},
	author = {Donald E. Wynn}
}
@article {1877,
	title = {Software security for open-source systems},
	journal = {IEEE Security \& Privacy Magazine},
	volume = {1},
	year = {2003},
	month = {01/2003},
	pages = {38 - 45},
	abstract = {Debate over whether open-source software development leads to more or less secure software has raged for years. Neither is intrinsically correct: open-source software gives both attackers and defenders greater power over system security. Fortunately, several security-enhancing technologies for open-source systems can help defenders improve their security.
},
	keywords = {security},
	issn = {1540-7993},
	doi = {10.1109/MSECP.2003.1176994},
	author = {Cowan, C.}
}
@conference {1248,
	title = {Supporting Distributed and Decentralized Projects: Drawing Lessons from the Open Source Community},
	booktitle = {1st Workshop on Open Source in an Industrial Context},
	year = {2003},
	note = {"We begin the remainder of the paper with discussion of a survey of open source projects, showing similarities that have arisen in tool usage"},
	month = {10/2003},
	abstract = {Open source projects are typically organized in a distributed and decentralized manner. These factors strongly determine the processes followed and constrain the types of tools that can be utilized. This paper explores how distribution and decentralization have affected processes and tools in existing open source projects with the goals of summarizing the lessons learned and identifying opportunities for improving both. Issues considered include decision-making, accountability, communication, awareness, rationale, managing source code, testing, and release management.},
	keywords = {abiword, apache, debian, freebsd, kde, linux, mozilla, mysql, perl, PHP, postgresql, python, subversion, tomcat, tools},
	attachments = {https://flosshub.org/sites/flosshub.org/files/erenkrantz2003.pdf},
	author = {Erenkrantz, J. and Taylor, R.N.}
}
@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}
}
@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 {stewart2002an-explorat,
	title = {An Exploratory Study of Factors Influencing the Level of Vitality and Popularity of Open Source Projects},
	booktitle = {ICIS 2002. Proceedings of International Conference on Information Systems 2002},
	year = {2002},
	note = {"We are currently tracking publicly available data on 240 open source projects registered on the freshmeat Website." "First, we randomly selected a total of 120 projects from the utilities, software development, and games and entertainment areas. We then selected 120 projects from these forums that had been registered on the site during the two weeks prior to the start of our data collection effort."},
	month = {2002},
	pages = {1-5},
	abstract = {In this research, we ask the question: What differentiates successful from unsuccessful open source software projects? Using a sample of 240 open source projects, we examine how organizational sponsorship, target audience (developer versus end user), license choice, and development status interact over time to influence the extent to which open source software projects attract user attention and developer activity.},
	keywords = {activity, audience, developers, freshmeat, license analysis, licenses, organizational sponsorship, project success, roles, status, target audience, users},
	author = {Stewart, Katherine J. and Ammeter, Tony}
}
@article {1095,
	title = {High Quality and Open Source Software Practices},
	journal = {Proceedings of the 2nd ICSE Workshop on Open Source},
	year = {2002},
	note = {"We examined the publicly visible portions of these projects from November 2001 through March 2002, ...The SLOC counts for the predominate languages are shown},
	month = {2002},
	abstract = {Surveys suggest that, according to various metrics, the quality and dependability of today{\textquoteright}s open source software is roughly on par with commercial and government developed software. What are the prospects for advancing to much higher levels of quality in open source software? More specifically, what attributes must be possessed by quality-related interventions for them to be feasibly adoptable in open source practice? In order to identify some of these attributes, we conducted a preliminary survey of the quality practices of a number of successful open source projects. We focus, in particular, on attributes related to adoptability by the open source practitioner community.},
	keywords = {apache, bug report, bug tracker, bug tracking system, feature requests, gcc, gnome, kde, lines of code, linux, loc, mozilla, netbeans, perl, position paper, python, sloc, source code, Survey, tomcat, xfree86},
	attachments = {https://flosshub.org/sites/flosshub.org/files/HalloranScherlis.pdf},
	author = {T. Halloran and W. Scherlis}
}
@article {hansen2002open,
	title = {The Open Source approach{\textemdash}opportunities and limitations with respect to security and privacy},
	journal = {Computers \& Security},
	volume = {21},
	number = {5},
	year = {2002},
	pages = {461{\textendash}471},
	publisher = {Elsevier},
	abstract = {Today{\textquoteright}s software often does not even fulfil basic security or privacy requirements. Some people regard the open source paradigm as the solution to this problem. First, we carefully explain the security and privacy aspects of open source, which in particular offer the possibility for a dramatic increase in trustworthiness for and autonomy of the user. We show which expectations for an improvement of the software trustworthiness dilemma are realistic. Finally, we describe measures necessary for developing secure and trustworthy open source systems.},
	keywords = {security},
	url = {https://dud.inf.tu-dresden.de/literatur/HaKP_02OpenSource_0214.doc},
	attachments = {https://flosshub.org/sites/flosshub.org/files/HaKP_02OpenSource_0214.doc},
	author = {Hansen, Marit and K{\"o}hntopp, Kristian and Pfitzmann, Andreas}
}
@inbook {Madey_Freeh_Tynan_2002,
	title = {The open source software development phenomenon: An analysis based on social network theory},
	booktitle = {Proceedings of the Eighth Americas Conference on Information Systems},
	year = {2002},
	pages = {1806{\textendash}1813},
	abstract = {The OSS movement is a phenomenon that challenges many traditional theories in economics, software engineering, business strategy, and IT management. Thousands of software programmers are spending tremendous amounts of time and effort writing and debugging software, most often with no direct monetary compensation. The programs, some of which are extremely large and complex, are written without the benefit of traditional project management, change tracking, or error checking techniques. Since the programmers are working outside of a traditional organizational reward structure, accountability is an issue as well. A significant portion of internet e-commerce runs on OSS, and thus many firms have little choice but to trust mission-critical e-commerce systems to run on such software, requiring IT management to deal with new types of socio-technical problems. A better understanding of how the OSS community functions may help IT planners make more informed decisions and develop more effective strategies for using OSS software. We hypothesize that open source software development can be modeled as self-organizing, collaboration, social networks. We analyze structural data on over 39,000 open source projects hosted at SourceForge.net involving over 33,000 developers. We define two software developers to be connected part of a collaboration social network if they are members of the same project, or are connected by a chain of connected developers. Project sizes, developer project participation, and clusters of connected developers are analyzed. We find evidence to support our hypothesis, primarily in the presence of power-law relationships on project sizes (number of developers per project), project membership (number of projects joined by a developer), and cluster sizes. Potential implications for IT researchers, IT managers, and governmental policy makers are discussed.},
	keywords = {developers, social network analysis, social networks, sourceforge},
	url = {http://ais.bepress.com/cgi/viewcontent.cgi?article=1606\&context=amcis2002},
	attachments = {https://flosshub.org/sites/flosshub.org/files/MadeyFreehAmcis2002.pdf},
	author = {Madey, G. and Freeh, V and Tynan, R}
}
@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}
}
@article {flosswp63,
	title = {The Scope of Open Source Licensing},
	journal = {Journal of Law, Economics and Organization},
	volume = {21},
	number = {1},
	year = {2002},
	month = {2005},
	pages = {20-56},
	abstract = {This paper is an initial exploration of the determinants of open source license choice. It first enumerates the various considerations that should figure into the licensor{\textquoteright}s choice of contractual terms, in particular highlighting how the decision is shaped not just by the preferences of the licensor itself, but also by that of the community of developers. The paper then presents an empirical analysis of the determinants of license choice using the SourceForge database, a compilation of nearly 40,000 open source projects. Projects geared toward end-users tend to have restrictive licenses, while those oriented toward developers are less likely to do so. Projects that are designed to run on commercial operating systems and those geared towards the Internet are less likely to have restrictive licenses. Finally, projects that are likely to be attractive to consumers such as games are more likely to have restrictive licenses.},
	keywords = {developers, license, licenses, permissive, restrictive, sourceforge},
	attachments = {https://flosshub.org/sites/flosshub.org/files/lernertirole2.pdf},
	author = {Josh Lerner and Jean Tirole}
}
@booklet {anderson2002security,
	title = {Security in open versus closed systems{\textemdash}the dance of Boltzmann, Coase and Moore},
	year = {2002},
	publisher = {Technical report, Cambridge University, England},
	abstract = {Some members of the open-source and free software com- munity argue that their code is more secure, because vulnerabilities are easier for users to find and fix. Meanwhile the proprietary vendor com- munity maintains that access to source code rather makes things easier for the attackers. In this paper, I argue that this is the wrong way to approach the interaction between security and the openness of design. I show first that under quite reasonable assumptions the security assur- ance problem scales in such a way that making it either easier, or harder, to find attacks, will help attackers and defendants equally. This model may help us focus on and understand those cases where some asymmetry is introduced.
However, there are more pressing security problems for the open source community. The interaction between security and openness is entangled with attempts to use security mechanisms for commercial advantage {\textendash} to entrench monopolies, to control copyright, and above all to control interoperability. As an example, I will discuss TCPA, a recent initiative by Intel and others to build DRM technology into the PC platform. Al- though advertised as providing increased information security for users, it appears to have more to do with providing commercial advantage for vendors, and may pose an existential threat to open systems.},
	keywords = {security},
	url = {http://www.cl.cam.ac.uk/~rja14/Papers/toulouse.pdf},
	attachments = {https://flosshub.org/sites/flosshub.org/files/toulouse.pdf},
	author = {Anderson, Ross}
}
@article {payne2002security,
	title = {On the security of open source software},
	journal = {Information systems journal},
	volume = {12},
	number = {1},
	year = {2002},
	pages = {61{\textendash}78},
	publisher = {Wiley Online Library},
	abstract = {With the rising popularity of so-called {\textquoteleft}open source{\textquoteright} software there has been increasing interest in both its various benefits and disadvantages. In particular, despite its prominent use in providing many aspects of the Internet{\textquoteright}s basic infrastructure, many still question the suitability of such software for the commerce-oriented Internet of the future. This paper evaluates the suitability of open source software with respect to one of the key attributes that tomorrow{\textquoteright}s Internet will require, namely security. It seeks to present a variety of arguments that have been made, both for and against open source security and analyses in relation to empirical evidence of system security from a previous study. The results represent preliminary quantitative evidence concerning the security issues surrounding the use and development of open source software, in particular relative to traditional proprietary software.},
	keywords = {security},
	attachments = {https://flosshub.org/sites/flosshub.org/files/Payne2002_ISJ12_SecurityOSS.pdf},
	author = {Payne, Christian}
}
@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 {Madey02understandingoss,
	title = {Understanding oss as a self-organizing process},
	booktitle = {In The 2nd Workshop on Open Source Software Engineering at the 24th International Conference on Software Engineering (ICSE2002},
	year = {2002},
	abstract = {We hypothesize that open source software development can be modeled as self-organizing, collaboration, social networks. We analyze structural data on over 39,000 open source projects hosted at SourceForge.net. We define two software developers to be connected {\textemdash} part of a collaboration social network {\textemdash} if they are members of the same project, or are connected by a chain of connected developers. Project sizes, developer project participation, and clusters of connected developers are analyzed. We find evidence to support our hypothesis, primarily in the presence of power-law relationships on project sizes (number of developers per project), project membership (number of projects joined by a developer), and cluster sizes.},
	keywords = {developers, size, social network analysis, social networks, sourceforge},
	attachments = {https://flosshub.org/sites/flosshub.org/files/MadeyFreehTynan.pdf},
	author = {Madey, G. and Freeh, V and Tynan, R}
}
@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}
}
@article {witten2001does,
	title = {Does open source improve system security?},
	journal = {IEEE Software},
	volume = {18},
	number = {5},
	year = {2001},
	pages = {57{\textendash}61},
	publisher = {IEEE},
	abstract = {An attacker
could examine
public source
code to find
flaws in a
system. So, is
source code
access a net
gain or loss for
security? The
authors
consider this
question from
several
perspectives
and tentatively
conclude that
having source
code available
should work in
favor of system
security.},
	keywords = {security},
	url = {https://pdfs.semanticscholar.org/71f6/01579ad1c373ed59a19eba0396f7f0cb7a0e.pdf},
	attachments = {https://flosshub.org/sites/flosshub.org/files/01579ad1c373ed59a19eba0396f7f0cb7a0e.pdf},
	author = {Witten, Brian and Landwehr, Carl and Caloyannides, Michael}
}
@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 {1135,
	title = {Software Architectures and Open Source Software {\textendash} Where can Research Leverage the Most?},
	booktitle = {1st Workshop on Open Source Software Engineering at ICSE 2001},
	year = {2001},
	month = {05/2001},
	abstract = {Software architectures have been playing a central role in software engineering research for some years now. They are considered of pivotal importance in the success of complex software systems development. However, with the emergence of Open Source Software (OSS) development, a new opportunity for studying architectural issues arises. In this paper, we introduce accepted notions of software architectures (Section 2), discuss some of the known issues in OSS (Section 3), resulting in a set of aspects we consider to be relevant for future research (Section 4).},
	keywords = {architecture, software architecture},
	attachments = {https://flosshub.org/sites/flosshub.org/files/ariefgaceklawrie.pdf},
	author = {Arief, B. and Gacek, C. and Lawrie, T.}
}
@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}
}
@conference {1142,
	title = {Software Engineering Research in the Bazaar},
	booktitle = {1st Workshop on Open Source Software Engineering at ICSE 2001},
	year = {2001},
	note = {"To gain a better understanding of a software system, we recover its software architecture from the system{\textquoteright}s source code.
We recovered the architecture of many open source systems such as the Linux kernel [3], the Mozilla browser [5], the Apache web server [7], and the VIM editor [14]. The recovered architecture is browse-able to permit developers to interact with it, [10] shows an example for the Linux kernel."},
	abstract = {During the last five years, our research group has studied the architecture and evolution of several large open source systems {\textemdash} including Linux, GCC, VIM, Mozilla, and Apache {\textemdash} and we have found that open source software systems often exhibit interesting differences when compared to similar commercially-developed systems. Our investigations of these systems have involved the creation of software architecture models, software architecture repair, the creation of a reference architecture for web servers, the study of evolution and growth of open source systems, and the modelling of architectural properties of systems that are apparent only at build time.},
	keywords = {apache, architecture, gcc, kernel, linux, linux kernel, mozilla, open source software, software architecture, Software Engineering Research, source code, vim},
	attachments = {https://flosshub.org/sites/flosshub.org/files/hassangodfreyholt.pdf},
	author = {Hassan, Ahmed E. and Godfrey, Michael W. and Holt, Richard C.}
}
@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}
}
@conference {Godfrey:2000:EOS:850948.853411,
	title = {Evolution in Open Source Software: A Case Study},
	booktitle = {Proceedings of the International Conference on Software Maintenance (ICSM{\textquoteright}00)},
	series = {ICSM {\textquoteright}00},
	year = {2000},
	note = {"We examined 96 kernel versions..."
.c files, .h files only
loc, lines of code
number of functions
number of modules},
	pages = {131{\textendash}},
	publisher = {IEEE Computer Society},
	organization = {IEEE Computer Society},
	address = {Washington, DC, USA},
	abstract = {Most studies of software evolution have been performed on systems developed within a single company using traditional management techniques. With the widespread availability of several large software systems that have been developed using an {\textquoteright}open source{\textquoteright} development approach, we now have a chance to examine these systems in detail, and see if their evolutionary narratives are significantly different from commercially developed systems. This paper summarizes our preliminary investigations into the evolution of the best known open source system: the Linux operating system kernel. Because Linux is large (over two million lines of code in the most recent version) and because its development model is not as tightly planned and managed as most industrial software processes, we had expected to find that Linux was growing more slowly as it got bigger and more complex. Instead, we have found that Linux has been growing at a super-linear rate for several years. In this paper, we explore the evolution of the Linux kernel both at the system level and within the major subsystems, and we discuss why we think Linux continues to exhibit such strong growth.},
	keywords = {evolution, functions, growth, lines of code, linux, linux kernel, loc, source code},
	isbn = {0-7695-0753-0},
	url = {http://portal.acm.org/citation.cfm?id=850948.853411},
	attachments = {https://flosshub.org/sites/flosshub.org/files/godfrey00.pdf},
	author = {Godfrey, Michael W. and Tu, Qiang}
}
