@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 {1914,
	title = {Practices and Perceptions of UML Use in Open Source Projects},
	year = {2017},
	month = {05/2017},
	pages = {203-212},
	abstract = {Context: Open Source is getting more and more
collaborative with industry. At the same time, modeling is today
playing a crucial role in development of, e.g., safety critical
software. Goal: However, there is a lack of research about the
use of modeling in Open Source. Our goal is to shed some
light into the motivation and benefits of the use of modeling
and its use within project teams. Method: In this study, we
perform a survey among Open Source developers. We focus on
projects that use the Unified Modeling Language (UML) as a
representative for software modeling. Results: We received 485
answers of contributors of 458 different Open Source projects.
Conclusion: Collaboration seems to be the most important
motivation for using UML. It benefits new contributors and
contributors who do not create models. Teams use UML during
communication and planning of joint implementation efforts.},
	keywords = {architecture documentation, communication, effectiveness of UML, github, MOTIVATION, UML},
	author = {Truong Ho-Quang and Hebig, Regina and Gregorio Robles and Chaudron, Michel R. V. and Miguel Angel Fernandez}
}
@proceedings {1900,
	title = {Understanding When to Adopt a Library: A Case Study on ASF Projects},
	volume = {496},
	year = {2017},
	month = {05/2017},
	pages = {128-138},
	publisher = {Springer},
	abstract = {Software libraries are widely used by both industrial and open source client projects. Ideally, a client user of a library should adopt the latest version that the library project releases. However, sometimes the latest version is not better than a previous version. This is because the latest version may include additional developer effort to test and integrate all changed features. In this study, our main goal is to better understand the relationship between adoption of library versions and its release cycle. Specifically, we conducted an empirical study of release cycles for 23 libraries and how they were adopted by 415 Apache Software Foundation (ASF) client projects. Our findings show that software projects are quicker to update earlier rapid-release libraries compared to library projects with a longer release cycle. Moreover, results suggest that software projects are more likely to adopt the latest version of a rapid-release library compared to libraries with a longer release cycles.},
	keywords = {adoption, apache, apache software foundation, libraries},
	doi = {10.1007/978-3-319-57735-7_13},
	url = {https://link.springer.com/chapter/10.1007/978-3-319-57735-7_13},
	author = {Ihara, Akinori and Daiki Fujibayashi and Hirohiko Suwa and Raula Gaikovina Kula and Kenichi Matsumoto}
}
@proceedings {1921,
	title = {Who Added that Permission to My App? An Analysis of Developer Permission Changes in Open Source Android Apps},
	year = {2017},
	note = {"Our first step was to collect open source Android repositories
from F-Droid ... We collected the git repositories for each
app, ... we recorded
all permissions, including those which were custom. 
At the time of our analysis, F-Droid contained information
for 2,372 open source Android apps. ... This process
identified 1,402 apps that had a AndroidManifest.xml file
with a history of commits... we created a tool
known as Open Source Android Repository Analyzer (oSARA)...we extracted version control
commit information ... extracts all committed AndroidManifest.xml
files from the version control history ...the committed
version of the AndroidManifest.xml file was also extracted
from the repositories, and all metadata was stored in a SQLite
database"},
	month = {05/2017},
	pages = {165-169},
	abstract = {Android applications rely on a permission-based
model to carry out core functionality. Appropriate permission
usage is imperative for ensuring device security and protecting
the user{\textquoteright}s desired privacy levels. But who is making the important
decisions of which permissions the app should request? Are they
experienced developers with the appropriate project knowledge to
make such important decisions, or are these crucial choices being
made by those with relatively minor amounts of contributions to
the project? When are these permission-related decisions being
made in the app{\textquoteright}s development life cycle? We examined 1,402
Android version control repositories containing over 331,318
commits including 18,751 AndroidManifest.xml versions to better
understand when, why, and who is adding permissions to apps.
We found that (I) developers with more experience are more
likely to make permission-based changes (II) permissions are
typically added earlier in apps{\textquoteright} commit lifetime, but their
removal is more sustained throughout the commit lifetime (III)
developers reverting permission-based changes are typically more
experienced than developers who initially made the change being
reverted.},
	keywords = {android, mobile},
	author = {Krutz, Daniel E. and Nuthan Munaiah and Anthony Peruma and Mohamed Wiem Mkaouer}
}
@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 {1763,
	title = {A Dataset of High Impact Bugs: Manually-Classified Issue Reports},
	year = {2015},
	month = {05/2015},
	publisher = {IEEE},
	abstract = {The importance of supporting test and maintenance
activities in software development has been increasing, since
recent software systems have become large and complex. Although
in the field of Mining Software Repositories (MSR) there
are many promising approaches to predicting, localizing, and
triaging bugs, most of them do not consider impacts of each
bug on users and developers but rather treat all bugs with equal
weighting, excepting a few studies on high impact bugs including
security, performance, blocking, and so forth. To make MSR
techniques more actionable and effective in practice, we need
deeper understandings of high impact bugs. In this paper we
introduced our dataset of high impact bugs which was created
by manually reviewing four thousand issue reports in four open
source projects (Ambari, Camel, Derby and Wicket).},
	keywords = {ambari, camel, derby, wicket},
	url = {http://oss.sys.wakayama-u.ac.jp/publications/pman3.cgi?DOWNLOAD=141},
	attachments = {https://flosshub.org/sites/flosshub.org/files/5594a518.pdf},
	author = {Ohira, Masao and Yutaro Kashiwa and Yosuke Yamatani and Hayato Yoshiyuki and Yoshiya Maeda and Nachai Limsettho and Keisuke Fujino and Hata, Hideaki and Ihara, Akinori and Kenichi Matsumoto}
}
@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}
}
@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 {1767,
	title = {Toward Reusing Code Changes},
	year = {2015},
	month = {05/2015},
	publisher = {IEEE},
	abstract = {Existing techniques have succeeded to help developers
implement new code. However, they are insufficient to help to
change existing code. Previous studies have proposed techniques
to support bug fixes but other kinds of code changes such
as function enhancements and refactorings are not supported
by them. In this paper, we propose a novel system that helps
developers change existing code. Unlike existing techniques, our
system can support any kinds of code changes if similar code
changes occurred in the past. Our research is still on very early
stage and we have not have any implementation or any prototype
yet. This paper introduces our research purpose, an outline of our
system, and how our system is different from existing techniques.},
	keywords = {apache},
	url = {http://sdl.ist.osaka-u.ac.jp/~higo/data/ICSE15-MSR-05-p052.pdf},
	attachments = {https://flosshub.org/sites/flosshub.org/files/ICSE15-MSR-05-p052.pdf},
	author = {Higo, Yoshiki and Akio Ohtani and Shinpei Hayashi and Hata, Hideaki and Kusumoto Shinji}
}
@proceedings {1752,
	title = {Why Power Laws? An Explanation from Fine-Grained Code Changes},
	year = {2015},
	note = {"The data used in this section come from four open source Java projects. We used CVSANALY to collect data from their Git repositories."},
	abstract = {Throughout the years, empirical studies have found
power law distributions in various measures across many software
systems. However, surprisingly little is known about how
they are produced. What causes these power law distributions?
We offer an explanation from the perspective of fine-grained
code changes. A model based on preferential attachment and selforganized
criticality is proposed to simulate software evolution.
The experiment shows that the simulation is able to render power
law distributions out of fine-grained code changes, suggesting
preferential attachment and self-organized criticality are the
underlying mechanism causing the power law distributions in
software systems.},
	keywords = {Apache Maven, cvsanaly, eclipse, git, Google Guice, java, jedit, open source},
	url = {https://users.soe.ucsc.edu/~linzhp/msr2015.pdf},
	attachments = {https://flosshub.org/sites/flosshub.org/files/msr2015.pdf},
	author = {Zhongpeng Lin and Jim Whitehead}
}
@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.}
}
@inbook {1625,
	title = {Automation of Agricultural Irrigation System with Open Source},
	booktitle = {Open Source Software: Mobile Open Source Technologies},
	series = {IFIP Advances in Information and Communication Technology},
	volume = {427},
	year = {2014},
	pages = {232-233},
	publisher = {Springer Berlin Heidelberg},
	organization = {Springer Berlin Heidelberg},
	abstract = {

In this present job, we seek to develop a prototype of an automated agricultural irrigation system, monitored and controlled remotely. For that, we will use inexpensive tools, flexibility and support such as Arduino, XBee and Android. Arduino and XBee, will be responsible of the automating the system. Android will achieve the remote monitoring and control from anywhere in the world where there is cellular service and Internet. In this way we can give the farmer the comfort and security that he don{\textquoteright}t get with a manually controlled system.
},
	keywords = {ADK, android, Arduino, XBee},
	isbn = {978-3-642-55127-7},
	doi = {10.1007/978-3-642-55128-4_36},
	url = {http://dx.doi.org/10.1007/978-3-642-55128-4_36},
	author = {Quezada, BladimirJaimeP{\'e}rez and Fern{\'a}ndez, Javier},
	editor = {Corral, Luis and Sillitti, Alberto and Succi, Giancarlo and Vlasenko, Jelena and Wasserman, AnthonyI.}
}
@conference {Rozas:2014:DCP:2641580.2641624,
	title = {Drupal As a Commons-Based Peer Production Community: A Sociological Perspective},
	booktitle = {Proceedings of The International Symposium on Open Collaboration},
	series = {OpenSym {\textquoteright}14},
	year = {2014},
	pages = {36:1{\textendash}36:2},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {The aim of this research consists of extracting a set of insights related to the dynamics, group decision making procedures, motivations to contribute and mechanisms employed in the coordination of Commons-Based Peer Production communities, using as a case study the community responsible for the development of the Free/Libre Open Source Software Drupal. A sociological perspective is taken for this purpose, and a set of social research qualitative and quantitative methods employed for the study of online communities (virtual ethnography) are being used.
},
	keywords = {Activity Theory, Commons-Based Peer Production, drupal, Free/Libre Open Source Software, Virtual Ethnography},
	isbn = {978-1-4503-3016-9},
	doi = {10.1145/2641580.2641624},
	url = {http://doi.acm.org/10.1145/2641580.2641624},
	author = {Rozas, David}
}
@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.}
}
@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 {Ahmed:2014:IAC:2641580.2641585,
	title = {The Impact of Automatic Crash Reports on Bug Triaging and Development in Mozilla},
	booktitle = {Proceedings of The International Symposium on Open Collaboration},
	series = {OpenSym {\textquoteright}14},
	year = {2014},
	pages = {1:1{\textendash}1:8},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {Free/Open Source Software projects often rely on users submitting bug reports. However, reports submitted by novice users may lack information critical to developers, and the process may be intimidating and difficult. To gather more and better data, projects deploy automatic crash reporting tools, which capture stack traces and memory dumps when a crash occurs. These systems potentially generate large volumes of data, which may overwhelm developers, and their presence may discourage users from submitting traditional bug reports. In this paper, we examine Mozilla{\textquoteright}s automatic crash reporting system and how it affects their bug triaging process. We find that fewer than 0.00009\% of crash reports end up in a bug report, but as many as 2.33\% of bug reports have data from crash reports added. Feedback from developers shows that despite some problems, these systems are valuable. We conclude with a discussion of the pros and cons of automatic crash reporting systems.
},
	keywords = {Automatic Crash reporting, debugging, FOSS, Free/Open Source Software, Open Bug Reporting, testing},
	isbn = {978-1-4503-3016-9},
	doi = {10.1145/2641580.2641585},
	url = {http://doi.acm.org/10.1145/2641580.2641585},
	author = {Ahmed, Iftekhar and Mohan, Nitin and Jensen, Carlos}
}
@conference {Farah:2014:OSA:2597073.2597135,
	title = {OpenHub: A Scalable Architecture for the Analysis of Software Quality Attributes},
	booktitle = {Proceedings of the 11th Working Conference on Mining Software Repositories},
	series = {MSR 2014},
	year = {2014},
	pages = {420{\textendash}423},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {There is currently a vast array of open source projects available on the web, and although they are searchable by name or description in the search engines, there is no way to search for projects by how well they perform on a given set of quality attributes (e.g. usability or maintainability). With OpenHub, we present a scalable and extensible architecture for the static and runtime analysis of open source repositories written in Python, presenting the architecture and pinpointing future possibilities with it.
},
	keywords = {architecture, github, python, Quality Attributes},
	isbn = {978-1-4503-2863-0},
	doi = {10.1145/2597073.2597135},
	url = {http://doi.acm.org/10.1145/2597073.2597135},
	author = {Farah, Gabriel and Tejada, Juan Sebastian and Correal, Dario}
}
@article {1817,
	title = {Understanding Contributor to Developer Turnover Patterns in OSS Projects: A Case Study of Apache Projects},
	journal = {ISRN Software Engineering},
	volume = {201411},
	year = {2014},
	month = {2014},
	pages = {1 - 10},
	abstract = {OSS projects are dynamic in nature. Developers
contribute to a project for a certain period of time and later
leave the project or join other projects of high interest. Hence,
the OSS community always welcomes members who can attain
the role of a developer in a project. In this paper, we investigate
contributions made by members who have attained the role of
a developer. In particular, we study the contributions made by
the members in terms of bugs reported, comments on bugs,
source-code patch submissions, and their social relation with
other members of an OSS community. Further, we study the
significance of nondevelopers contribution and investigate if
and to what extent they play a role in the long-term survival
of an OSS project. Moreover, we investigate the ratio of
contributions made by a member before and after attaining
the role of a developer. We have outlined 4 research questions
in this regard and further discuss our findings based on the
research questions by taking into account data from software
repositories of 4 different Apache projects.},
	keywords = {apache},
	doi = {10.1155/2014/535724},
	author = {Iqbal, Aftab}
}
@proceedings {1488,
	title = {Apache-Affiliated Twitter Screen Names: A Dataset},
	year = {2013},
	month = {05/2013},
	abstract = {This paper describes a new dataset containing Twitter screen names for members of the projects affiliated with the Apache Software Foundation (ASF). The dataset includes the confirmed Twitter screen names, as well as the real name as listed on Twitter, and the user identification as used within the Apache organization. The paper also describes the process used to collect and clean this data, and shows some sample queries for learning how to use the data. The dataset has been donated to the FLOSSmole project and is available for download (https://code. google.com/p/flossmole/downloads/detail?name=apacheTwitter2013-Jan.zip) or direct querying via a database client. },
	keywords = {apache, dataset, twitter},
	attachments = {https://flosshub.org/sites/flosshub.org/files/apacheTwitterPREPRINT.pdf , https://flosshub.org/sites/flosshub.org/files/MSR\%20presentation.pdf},
	author = {Squire, Megan}
}
@article {bettenburg2013management,
	title = {Management of community contributions},
	journal = {Empirical Software Engineering},
	year = {2013},
	pages = {1{\textendash}38},
	publisher = {Springer},
	abstract = {In recent years, many companies have realized that collaboration with a thriving user or developer community is a major factor in creating innovative technology driven by market demand. As a result, businesses have sought ways to stimulate contributions from developers outside their corporate walls, and integrate external developers into their development process. To support software companies in this process, this paper presents an empirical study on the contribution management processes of two major, successful, open source software ecosystems. We contrast a for-profit (ANDROID) system having a hybrid contribution style, with a not-for-profit (LINUX kernel) system having an open contribution style. To guide our comparisons, we base our analysis on a conceptual model of contribution management that we derived from a total of seven major open-source software systems. A quantitative comparison based on data mined from the ANDROID code review system and the LINUX kernel code review mailing lists shows that both projects have significantly different contribution management styles, suited to their respective market goals, but with individual advantages and disadvantages that are important for practitioners. Contribution management is a real-world problem that has received very little attention from the research community so far. Both studied systems (LINUX and ANDROID) employ different strategies and techniques for managing contributions, and both approaches are valuable examples for practitioners. Each approach has specific advantages and disadvantages that need to be carefully evaluated by practitioners when adopting a contribution management process in practice.},
	keywords = {android, contribution, linux, management},
	url = {http://link.springer.com/article/10.1007/s10664-013-9284-6},
	author = {Bettenburg, Nicolas and Hassan, Ahmed E. and Adams, Bram and Daniel M. German}
}
@proceedings {1489,
	title = {Project Roles in the  Apache Software Foundation: A Dataset},
	year = {2013},
	month = {05/2013},
	abstract = {This paper outlines the steps in the creation and maintenance of a new dataset listing leaders of the various projects of the Apache Software Foundation (ASF). Included in this dataset are different levels of committers to the various ASF project code bases, as well as regular and emeritus members of the ASF, and directors and officers of the ASF. The dataset has been donated to the FLOSSmole project under an open source license, and is available for download (https://code.google.com /p/flossmole/downloads/detail?name=apachePeople2013-Jan.zip), or for direct querying via a database client.},
	keywords = {apache, dataset, roles},
	attachments = {https://flosshub.org/sites/flosshub.org/files/apacheRolesPREPRINT.pdf , https://flosshub.org/sites/flosshub.org/files/MSR\%20presentation_0.pdf},
	author = {Squire, Megan}
}
@proceedings {1561,
	title = {A Replicable Infrastructure for Empirical Studies of Email Archives},
	year = {2013},
	month = {10/2013},
	pages = {43-50},
	publisher = {IEEE},
	address = {Baltimore, MD, USA},
	abstract = {This paper describes a replicable infrastructure solution for conducting empirical software engineering studies based on email mailing list archives. Mailing list emails, such as those affiliated with free, libre, and open source software (FLOSS) projects, are currently archived in several places online, but each research team that wishes to study these email artifacts closely must design their own solution for collection, storage and cleaning of the data. Consequently, research results will be difficult to replicate, especially as the email archive for any living project will still be continually growing. This paper describes a simple, replicable infrastructure for the collection, storage, and cleaning of project email data and analyses.},
	keywords = {apache, cleaning, collection, couchdb, database, document-oriented database, email, lucene, mailing lists, nosql, replication, storage},
	isbn = {978-0-7695-5121-0},
	attachments = {https://flosshub.org/sites/flosshub.org/files/RESERv2.pdf},
	author = {Squire, Megan}
}
@proceedings {1498,
	title = {Who Does What during a Code Review? Datasets of OSS Peer Review Repositories },
	year = {2013},
	month = {05/2013},
	abstract = {We present four datasets that are focused on the general roles of OSS peer review members. With data mined from both an integrated peer review system and code source repositories, our rich datasets comprise of peer review data that was automatically recorded. Using the Android project as a case study, we describe our extraction methodology, the datasets and their application used for three separate studies. Our datasets are available online at http://sdlab.naist.jp/reviewmining/},
	keywords = {android, case study, code review, data set, peer review, roles, source code},
	author = {Kazuki Hamasaki and Raula Gaikovina Kula and Norihiro Yoshida and A. E. Camargo Cruz and Kenji Fujiwara and Hajimu Iida}
}
@article {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 {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 {1321,
	title = {Factors Affecting the Development of Absorptive Capacity in the Adoption of Open Source Software},
	journal = {International Journal of Open Source Software and Processes},
	volume = {3},
	year = {2011},
	pages = {17 - 38},
	abstract = {Previous research has shown that the knowledge that is available to an organization is an important factor influencing the adoption of open source software (OSS). Hence, it is important that organizations develop their absorptive capacity in order to successfully adopt OSS. Absorptive capacity refers to the ability of an organization to acquire, assimilate, and exploit new knowledge. However, no study has specifically investigated how organizations can develop their absorptive capacity by acquiring knowledge about OSS. This paper addresses this gap in research by investigating the organizational knowledge assimilation process within the context of the adoption of OSS. Based on a case study conducted at the Flemish government, a framework that is grounded in literature and that illustrates which contextual factors influence the development of absorptive capacity in the context of the adoption of OSS was developed.},
	keywords = {adoption, government},
	issn = {1942-3934},
	doi = {10.4018/jossp.2011010102},
	author = {Ven, Kris and De Bruyn, Peter}
}
@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}
}
@proceedings {1277,
	title = {Knowledge Homogeneity and Specialization in the Apache HTTP Server Project},
	year = {2011},
	note = {"Our data set consists of the commit history and email archives for the Apache HTTP Server Project, spanning sixteen years (2/27/1995 - 1/31/2011)"

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

"If specialization exists within the httpd community, we should see distinct communities develop around topics. In addition, unique groups of developers should congregate around specialized subtopics. We examined the data from both angles: topical affinity and topic communities."
},
	month = {10/2011},
	pages = {106-122},
	publisher = {Springer},
	abstract = {We present an analysis of developer communication in the Apache HTTP Server project. Using topic modeling techniques we expose latent conceptual sub-communities arising from developer specialization within the greater developer population. However, we found that among the major contributors to the project, very little specialization exists. We present theories to explain this phenomenon, and suggest further research.},
	keywords = {apache, commits, developer, email, email archive, LDA, mailing list, revision control, revision history, scm, social network analysis, specialization, subversion, svn},
	url = {http://sequoia.cs.byu.edu/lab/files/pubs/MacLean2011a.pdf},
	attachments = {https://flosshub.org/sites/flosshub.org/files/MacLean2011a.pdf},
	author = {MacLean, Alexander C. and Pratt, Landon J. and Knutson, Charles D. and Ringger, Eric K.}
}
@proceedings {1281,
	title = {License Update and Migration Processes in Open Source Software Projects},
	year = {2011},
	note = {"The case studies in this report are part of an ongoing, multi-year research project discovering and modeling open source software processes. Our research methodology is ethnographically informed, applying a grounded theory to the analysis of artifacts found in OSS projects. The primary data sources in this study come from mailing list archives of the Apache and NetBeans projects."},
	month = {10/2011},
	pages = {177-195},
	publisher = {Springer},
	abstract = {Open source software (OSS) has increasingly been the subject of research efforts. Central to this focus is the nature under which the software can be distributed, used, and modified and the causes and consequent effects on software development, usage, and distribution. At present, we have little understanding of, what happens when these licenses change, what motivates such changes, and how new licenses are created, updated, and deployed. Similarly, little attention has been paid to the agreements under which contributions are made to OSS projects and the impacts of changes to these agreements. We might also ask these same questions regarding the licenses governing how individuals and groups contribute to OSS projects. This paper focuses on addressing these questions with case studies of processes by which the Apache Software Foundation{\textquoteright}s creation and migration to Version 2.0 of the Apache Software License and the NetBeans project{\textquoteright}s migration to the Joint Licensing Agreement.},
	keywords = {apache, case study, email, email archive, license evolution, mailing list, netbeans, open source, process},
	attachments = {https://flosshub.org/sites/flosshub.org/files/1.pdf},
	author = {Chris Jensen and Walt Scacchi}
}
@article {1420,
	title = {Path dependent stochastic models to detect planned and actual technology use: A case study of OpenOffice},
	journal = {Information and Software Technology},
	volume = {53},
	year = {2011},
	month = {11/2011},
	pages = {1209 - 1226},
	abstract = {Abstract
Context

Adopting IT innovation in organizations is a complex decision process driven by technical, social and economic issues. Thus, those organizations that decide to adopt innovation take a decision of uncertain success of implementation, as the actual use of a new technology might not be the one expected. The misalignment between planned and effective use of innovation is called assimilation gap.
Objective

This research aims at defining a quantitative instrument for measuring the assimilation gap and applying it to the case of the adoption of OSS.
Method

In this paper, we use the theory of path dependence and increasing returns of Arthur. In particular, we model the use of software applications (planned or actual) by stochastic processes defined by the daily amounts of files created with the applications. We quantify the assimilation gap by comparing the resulting models by measures of proximity.
Results

We apply and validate our method to a real case study of introduction of OpenOffice. We have found a gap between the planned and the effective use despite well-defined directives to use the new OS technology. These findings suggest a need of strategy re-calibration that takes into account environmental factors and individual attitudes.
Conclusions

The theory of path dependence is a valid instrument to model the assimilation gap provided information on strategy toward innovation and quantitative data on actual use are available.},
	keywords = {Actual use of technology, Path dependence, Technology adoption, Urn models},
	issn = {09505849},
	doi = {10.1016/j.infsof.2011.05.002},
	url = {http://www.sciencedirect.com/science/article/pii/S0950584911001042},
	author = {Rossi, Bruno and Russo, Barbara and Succi, Giancarlo}
}
@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 {1398,
	title = {The search for a research method for studying OSS process innovation},
	journal = {Empirical Software Engineering},
	volume = {16},
	year = {2011},
	month = {8/2011},
	pages = {514 - 537},
	abstract = {Medium-sized, open-participation Open Source Software (OSS) projects do not usually perform explicit software process improvement on any routine basis. It would be useful to understand how to get such a project to accept a process improvement proposal and hence to perform process innovation. We want to determine an effective and feasible qualitative research method for studying the above question. We present (narratively) a case study of how we worked towards and eventually found such a research method. The case involves four attempts at collecting suitable data about innovation episodes (direct participation (twice), polling developers for episodes, manually finding episodes in mailing list archives) and the adaptation of the Grounded Theory data analysis methodology. Direct participation allows gathering rather rich data, but does not allow for observing a sufficiently large number of innovation episodes. Polling developers for episodes did not prove to be useful. Using mailing list archives to find data to be analyzed is both feasible and effective. We also describe how the data thus found can be analyzed based on the Grounded Theory Method with suitable adjustments. By-and-large, our findings ought to apply to studying various phenomena in OSS development processes that are similarly heavyweight and infrequent. However, specific details may block this possibility and we cannot predict which details that might be. The amount of effort involved in direct participation approaches to qualitative research can easily be underestimated. Also, survey approaches are not well-suited for many process issues in OSS, because too few developers are sufficiently process-conscious. An approach based on passive observation is a viable alternative in the OSS context due to the availability of large amounts of fairly complete archival data. },
	keywords = {argouml, Bochs, bugzilla, Flyspray, FreeDOS, gEDA, grounded theory, Grub, Innovation introduction, KVM, mailing list, Methodology, MonetDB, open source, Request Tracket, Rox, U-Boot, Xfce},
	issn = {1573-7616},
	doi = {10.1007/s10664-011-9160-1},
	author = {Prechelt, Lutz and Oezbek, Christopher}
}
@article {1325,
	title = {Tool Assisted Analysis of Open Source Projects},
	journal = {International Journal of Open Source Software and Processes},
	volume = {3},
	year = {2011},
	pages = {43 - 78},
	abstract = {Open Source Software (OSS) is currently a widely adopted approach to developing and distributing software. OSS code adoption requires an understanding of the structure of the code base. For a deeper understanding of the maintenance, bug fixing and development activities, the structure of the developer community also needs to be understood, especially the relations between the code and community structures. This, in turn, is essential for the development and maintenance of software containing OSS code. This paper proposes a method and support tool for exploring the relations of the code base and community structures of OSS projects. The method and proposed tool, Binoculars, rely on generic and reusable query operations, formal definitions of which are given in the paper. The authors demonstrate the applicability of Binoculars with two examples. The authors analyze a well-known and active open source project, FFMpeg, and the open source version of the IaaS cloud computing project Eucalyptus.},
	keywords = {artifacts, tools},
	issn = {1942-3934},
	doi = {10.4018/IJOSSP.2011040103},
	author = {Syeed, M.M. Mahbubul and Aaltonen, Timo and Hammouda, Imed and Syst{\"a}, Tarja}
}
@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 {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 {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 {951,
	title = {The evolution of ANT build systems},
	booktitle = {2010 7th IEEE Working Conference on Mining Software Repositories (MSR 2010)2010 7th IEEE Working Conference on Mining Software Repositories (MSR 2010)},
	year = {2010},
	pages = {42 - 51},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Cape Town, South Africa},
	abstract = {Build systems are responsible for transforming static source code artifacts into executable software. While build systems play such a crucial role in software development and maintenance, they have been largely ignored by software evolution researchers. With a firm understanding of build system aging processes, project managers could allocate personnel and resources to build system maintenance tasks more effectively, reducing the build maintenance overhead on regular development activities. In this paper, we study the evolution of ANT build systems from two perspectives: (1) a static perspective, where we examine the build system specifications using software metrics adopted from the source code domain; and (2) a dynamic perspective where representative sample build runs are conducted and their output logs are analyzed. Case studies of four open source ANT build systems with a combined history of 152 releases show that not only do ANT build systems evolve, but also that they need to react in an agile manner to changes in the source code.},
	keywords = {ant, argouml, build, eclipse, jboss, maintenance, metrics, source code, tomcat},
	isbn = {978-1-4244-6802-7},
	doi = {10.1109/MSR.2010.5463341},
	attachments = {https://flosshub.org/sites/flosshub.org/files/42msr2010_mcintosh.pdf},
	author = {McIntosh, Shane and Adams, Bram and Hassan, Ahmed E.}
}
@conference {950,
	title = {An extensive comparison of bug prediction approaches},
	booktitle = {2010 7th IEEE Working Conference on Mining Software Repositories (MSR 2010)2010 7th IEEE Working Conference on Mining Software Repositories (MSR 2010)},
	year = {2010},
	pages = {31 - 41},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Cape Town, South Africa},
	abstract = {Reliably predicting software defects is one of software engineering{\textquoteright}s holy grails. Researchers have devised and implemented a plethora of bug prediction approaches varying in terms of accuracy, complexity and the input data they require. However, the absence of an established benchmark makes it hard, if not impossible, to compare approaches. We present a benchmark for defect prediction, in the form of a publicly available data set consisting of several software systems, and provide an extensive comparison of the explanative and predictive power of well-known bug prediction approaches, together with novel approaches we devised. Based on the results, we discuss the performance and stability of the approaches with respect to our benchmark and deduce a number of insights on bug prediction models.},
	keywords = {apache, bug reports, eclipse, famix, lucene, mylyn, prediction, scm},
	isbn = {978-1-4244-6802-7},
	doi = {10.1109/MSR.2010.5463279},
	attachments = {https://flosshub.org/sites/flosshub.org/files/31dambrosLanzaRobbes31.pdf},
	author = {D{\textquoteright}Ambros, Marco and Lanza, Michele and Robbes, Romain}
}
@conference {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 {965,
	title = {Identifying licensing of jar archives using a code-search approach},
	booktitle = {2010 7th IEEE Working Conference on Mining Software Repositories (MSR 2010)2010 7th IEEE Working Conference on Mining Software Repositories (MSR 2010)},
	year = {2010},
	pages = {151 - 160},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Cape Town, South Africa},
	abstract = {Free and open source software strongly promotes the reuse of source code. Some open source Java components/libraries are distributed as jar archives only containing the bytecode and some additional information. For whoever wanting to integrate this jar in her own project, it is important to determine the license(s) of the code from which the jar archive was produced, as this affects the way that such component can be used. This paper proposes an automatic approach to determine the license of jar archives, combining the use of a code-search engine with the automatic classification of licenses contained in textual flies enclosed in the jar. Results of an empirical study performed on 37 jars - from 17 different systems - indicate that this approach is able to successfully infer the jar licenses in over 95\% of the cases, but that in many cases the license in textual flies may differ from the one of the classes contained in the jar.},
	keywords = {apache, bytecode, classification, eclipse, google code, jar, java, licenses, source code},
	isbn = {978-1-4244-6802-7},
	doi = {10.1109/MSR.2010.5463282},
	attachments = {https://flosshub.org/sites/flosshub.org/files/151msr2010.pdf},
	author = {Di Penta, Massimiliano and Daniel M. German and Antoniol, Giuliano}
}
@conference {1255,
	title = {{\textquoteright}Letting go of Control{\textquoteright} to Embrace Open Source: Implications for Company and Community},
	booktitle = {2010 43rd Hawaii International Conference on System Sciences (HICSS 2010)},
	year = {2010},
	pages = {1 - 10},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Honolulu, Hawaii, USA},
	abstract = {It is increasingly understood across the information technology and services sector that engagement with the open source software model can serve as a means for firms to capture intellectual energy, learn about productive software processes, access relevant technical skills, identify and recruit staff, as well as obtain valuable resources including code. This paper reports a study undertaken within two large global IT companies that have been actively involved with open source for more than ten years. The study involved over 30 semi-structured interviews with employees of the companies drawn from top, middle, and lower level management, and included active and experienced developer as well as open source community members. Our findings indicate how these companies have adapted their day-to-day management practices to take into account the need for flexibility and freedom expected by open source communities. This paper focuses on how they {\textquoteright}let go of control{\textquoteright} and what the implications of this are for both companies and the communities involved. Our data reveals a number of themes and in this paper we focus on three principal ones; issues of requirements, total cost of adoption, and alignment of open source engagement with long term company strategy.},
	keywords = {adoption, companies, interviews, organizations},
	isbn = {978-1-4244-5509-6},
	doi = {10.1109/HICSS.2010.1},
	attachments = {https://flosshub.org/sites/flosshub.org/files/07-06-01.pdf},
	author = {Maha Shaikh and Cornford, Tony}
}
@conference {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 {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 {1224,
	title = {On the Need for OSS Patch Contribution Tools},
	booktitle = {Second International Workshop on Building Sustainable Open Source Communities (OSCOMM 2010)},
	year = {2010},
	abstract = {Open Source Software (OSS) projects and systems have become significant parts of the software economy. The sustainability of an OSS project depends largely on community contributions. The patch contribution process is important to OSS projects. Nevertheless, there are several issues negatively impacting patch contribution in mature OSS projects. These issues can be addressed by improving tools to support the patch contribution process.},
	keywords = {apache, kanban, patch, patch acceptance, patches},
	attachments = {https://flosshub.org/sites/flosshub.org/files/osscomm004.pdf},
	author = {Bhuricha Deen Sethanandha and Bart Massey and William Jones}
}
@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 {962,
	title = {OSS developers context-specific Preferred Representational systems: A initial Neurolinguistic text analysis of the Apache mailing list},
	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 = {126 - 129},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Cape Town, South Africa},
	abstract = {Open Source Software (OSS) mailing lists are used by developers to discuss software engineering tasks performed in the project. In the last years, researchers have been conducting mailing lists linguistic analyses for understanding the intricacies of OSS development. An unpublished approach for that is to use NeuroLinguistic Theory (NT). NT postulates the use of a Preferred Representational cognitive System (PRS) in specific contexts. This means that different resources and cognitive channels are used by developers in order to understand software, but what types of representational systems are the preferred by software engineers? This paper introduces a psychometrically-based neuro-linguistic analysis tool to classify developers, and presents early results of an experiment to assess the PRS of four top developers against a baseline of the Apache server mailing list.},
	keywords = {apache, email, email archives, mailing lists, neurolinguistics},
	isbn = {978-1-4244-6802-7},
	doi = {10.1109/MSR.2010.5463339},
	author = {Junior, Methanias Colaco and Mendonca, Manoel and Farias, Mario and Henrique, Paulo}
}
@conference {967,
	title = {Should I contribute to this discussion?},
	booktitle = {2010 7th IEEE Working Conference on Mining Software Repositories (MSR 2010)},
	year = {2010},
	pages = {181 - 190},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Cape Town},
	abstract = {Development mailing lists play a central role in facilitating communication in open source projects. Since these lists frequently host design and project discussions, knowledgeable contribution to these discussion threads is essential to avoid mis-communication that might slow-down the progress of a project. However, given the sheer volume of emails on these lists, it is easy to miss important discussions. To find out how developers are able to deal with mailing list discussions, we study the main factors that encourage developers to contribute to the development mailing lists. We develop personalized models to automatically identify discussion threads that a developer would contribute to based on his previous contribution behavior. Case studies on development mailing lists of three open source projects (Apache, PostgreSQL and Python) show that the average accuracy of our models is 89-85\% and that the models vary significantly between different developers.},
	keywords = {apache, contributions, developers, email, email archives, mailing lists, postgresql, python},
	isbn = {978-1-4244-6802-7},
	doi = {10.1109/MSR.2010.5463345},
	attachments = {https://flosshub.org/sites/flosshub.org/files/181ibrahim-msr2010.pdf},
	author = {Ibrahim, Walid M and Bettenburg, Nicolas and Shihab, Emad and Adams, Bram and Hassan, Ahmed E.}
}
@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.}
}
@conference {1259,
	title = {Towards an Openness Rating System for Open Source Software},
	booktitle = {2010 43rd Hawaii International Conference on System Sciences (HICSS 2010)},
	year = {2010},
	pages = {1 - 8},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Honolulu, Hawaii, USA},
	abstract = {Many open source software projects are not very open to third party developers. The point of open source is to enable anyone to fix bugs or add desired capabilities without holding them hostage to the original developers. This principle is important because an open source project{\textquoteright}s developers may be unresponsive or unable to meet third party needs, even if funding support for requested improvements is offered.This paper presents a simple rating system for evaluating the openness of software distributions. The rating system considers factors such as platform portability, documentation, licensing, and contribution policy. Several popular open source products are rated in order to illustrate the efficacy of the rating system.},
	keywords = {alice, case study, contribution, documentation, freespire, galib, latex, license, linux, linux kernel, mediaportal, openness, openoffice, opensolaris, rating, unicon},
	isbn = {978-1-4244-5509-6},
	doi = {10.1109/HICSS.2010.405},
	attachments = {https://flosshub.org/sites/flosshub.org/files/10-07-04.pdf},
	author = {Bein, Wolfgang and Jeffery, Clinton}
}
@conference {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}
}
@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}
}
@conference {953,
	title = {When process data quality affects the number of bugs: Correlations in software engineering datasets},
	booktitle = {2010 7th IEEE Working Conference on Mining Software Repositories (MSR 2010)2010 7th IEEE Working Conference on Mining Software Repositories (MSR 2010)},
	year = {2010},
	pages = {62 - 71},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Cape Town, South Africa},
	abstract = {Software engineering process information extracted from version control systems and bug tracking databases are widely used in empirical software engineering. In prior work, we showed that these data are plagued by quality deficiencies, which vary in its characteristics across projects. In addition, we showed that those deficiencies in the form of bias do impact the results of studies in empirical software engineering. While these findings affect software engineering researchers the impact on practitioners has not yet been substantiated. In this paper we, therefore, explore (i) if the process data quality and characteristics have an influence on the bug fixing process and (ii) if the process quality as measured by the process data has an influence on the product (i.e., software) quality. Specifically, we analyze six Open Source as well as two Closed Source projects and show that process data quality and characteristics have an impact on the bug fixing process: the high rate of empty commit messages in Eclipse, for example, correlates with the bug report quality. We also show that the product quality - measured by number of bugs reported - is affected by process data quality measures. These findings have the potential to prompt practitioners to increase the quality of their software process and its associated data quality.},
	keywords = {apache, bug reports, eclipse, gnome, log files, mozilla, netbeans, openoffice.org, version control},
	isbn = {978-1-4244-6802-7},
	doi = {10.1109/MSR.2010.5463286},
	attachments = {https://flosshub.org/sites/flosshub.org/files/62bachmann-msr10.pdf},
	author = {Bachmann, Adrian and Bernstein, Abraham}
}
@conference {930,
	title = {Author entropy vs. file size in the GNOME suite of applications},
	booktitle = {2009 6th IEEE International Working Conference on Mining Software Repositories (MSR)2009 6th IEEE International Working Conference on Mining Software Repositories},
	year = {2009},
	pages = {91 - 94},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Vancouver, BC, Canada},
	abstract = {We present the results of a study in which author entropy was used to characterize author contributions per file. Our analysis reveals three patterns: banding in the data, uneven distribution of data across bands, and file size dependent distributions within bands. Our results suggest that when two authors contribute to a file, large files are more likely to have a dominant author than smaller files.},
	keywords = {author entropy, contributions, gnome, msr challenge},
	isbn = {978-1-4244-3493-0},
	doi = {10.1109/MSR.2009.5069484},
	author = {Casebolt, Jason R. and Krein, Jonathan L. and MacLean, Alexander C. and Knutson, Charles D. and Delorey, Daniel P.}
}
@conference {1360,
	title = {Benchmarking Lightweight Techniques to Link E-Mails and Source Code},
	booktitle = {2009 16th Working Conference on Reverse Engineering},
	year = {2009},
	note = {"We present different lightweight approaches that, exploiting the specific characteristics of e-mails and the ones of the source code, are capable of establishing a bi-directional link between source code entities and e-mails"

"We analyzed ArgoUML1, a UML modelling tool written in Java, developed over the course of approximately 9 years, and made available under the BSD Open Source License. We consider the release 0.28 (March 2009) that comprehends 2,197 classes. We employed the lightweight approaches to map such classes to the related e-mails in ArgoUML mailing lists.
ArgoUML e-mails are stored in six mailing lists (see Table I), for a total amount of 79,175 messages"

Figure 4 is helpful to understand what this does.},
	pages = {205 - 214},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Lille, France},
	abstract = {During the evolution of a software system, a large amount of information, which is not always directly related to the source code, is produced. Several researchers have provided evidence that the contents of mailing lists represent a valuable source of information: Through e-mails, developers discuss design decisions, ideas, known problems and bugs, etc. which are otherwise not to be found in the system.

A technical challenge in this context is how to establish the missing link between free-form e-mails and the system artifacts they refer to. Although the range of approaches is vast, establishing their accuracy remains a problem, as there is no benchmark against which to compare their performance.

To overcome this issue, we manually inspected a statistically significant number of e-mails pertaining to the ArgoUML system. Based on this benchmark, we present a variety of lightweight techniques to assign e-mails to software artifacts and measure their effectiveness in terms of precision and recall.},
	keywords = {argouml, email, mailing lists},
	isbn = {978-0-7695-3867-9},
	doi = {10.1109/WCRE.2009.44},
	attachments = {https://flosshub.org/sites/flosshub.org/files/wcre2009.pdf},
	author = {Bacchelli, Alberto and D{\textquoteright}Ambros, Marco and Lanza, Michele and Robbes, Romain}
}
@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 {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}
}
@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}
}
@article {1235,
	title = {Open Source Software Adoption: Anatomy of Success and Failure},
	journal = {International Journal of Open Source Software and Processes},
	volume = {1},
	number = {1},
	year = {2009},
	month = {01/2009},
	pages = {1-23},
	abstract = {Current estimates suggest widespread adoption of open source software (OSS) in organizations worldwide. However, the problematic nature of OSS adoption is readily evidenced in the fairly frequent reports of problems, unforeseen hold-ups, and outright abandonment of OSS implementation over time. Hibernia Hospital, an Irish public sector organization, have embarked on the adoption of a range of OSS applications over several years, some of which have been successfully deployed and remain in live use within the organisation, whereas others, despite achieving high levels of assimilation over a number of years, have not been ultimately retained in live use in the organization. Using a longitudinal case study, we discuss in depth the deployment process for two OSS applications {\textendash} the desktop application suite whose deployment was unsuccessful ultimately, and the email application which was successfully deployed. To our knowledge, this is the first such in-depth study into successful and unsuccessful OSS implementation.},
	keywords = {adoption, project failure, project success},
	doi = {10.4018/jossp.2009010101},
	author = {Fitzgerald, Brian}
}
@conference {924,
	title = {A platform for software engineering research},
	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 = {31 - 40},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Vancouver, BC, Canada},
	abstract = {Research in the fields of software quality, maintainability and evolution requires the analysis of large quantities of data, which often originate from open source software projects. Collecting and preprocessing data, calculating metrics, and synthesizing composite results from a large corpus of project artifacts is a tedious and error prone task lacking direct scientific value. The Alitheia Core tool is an extensible platform for software quality analysis that is designed specifically to facilitate software engineering research on large and diverse data sources, by integrating data collection and preprocessing phases with an array of analysis services, and presenting the researcher with an easy to use extension mechanism. Alitheia Core aims to be the basis of an ecosystem of shared tools and research data that will enable researchers to focus on their research questions at hand, rather than spend time on re-implementing analysis tools. In this paper, we present the Alitheia Core platform in detail and demonstrate its usefulness in mining software repositories by guiding the reader through the steps required to execute a simple experiment.},
	keywords = {alitheia core},
	isbn = {978-1-4244-3493-0},
	doi = {10.1109/MSR.2009.5069478},
	attachments = {https://flosshub.org/sites/flosshub.org/files/31gousios.pdf},
	author = {Gousios, Georgios and Diomidis Spinellis}
}
@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}
}
@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 {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 {938,
	title = {Using association rules to study the co-evolution of production \& test code},
	booktitle = {2009 6th IEEE International Working Conference on Mining Software Repositories (MSR)2009 6th IEEE International Working Conference on Mining Software Repositories},
	year = {2009},
	pages = {151 - 154},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Vancouver, BC, Canada},
	abstract = {Unit tests are generally acknowledged as an important aid to produce high quality code, as they provide quick feedback to developers on the correctness of their code. In order to achieve high quality, well-maintained tests are needed. Ideally, tests co-evolve with the production code to test changes as soon as possible. In this paper, we explore an approach based on association rule mining to determine whether production and test code co-evolve synchronously. Through two case studies, one with an open source and another one with an industrial software system, we show that our association rule mining approach allows one to assess the co-evolution of product and test code in a software project and, moreover, to uncover the distribution of programmer effort over pure coding, pure testing, or a more test-driven-like practice.},
	keywords = {association rules, checkstyle, source code, unit test},
	isbn = {978-1-4244-3493-0},
	doi = {10.1109/MSR.2009.5069493},
	attachments = {https://flosshub.org/sites/flosshub.org/files/151UsingAssociation.pdf},
	author = {Lubsen, Zeeger and Zaidman, Andy and Pinzger, Martin}
}
@conference {597,
	title = {Using FLOSS Project Metadata in the Undergraduate Classroom},
	booktitle = {OSS2009: Open Source Ecosystems: Diverse Communities Interacting (IFIP 2.13)},
	series = {IFIP Advances in Information and Communication Technology },
	volume = {299/2009},
	year = {2009},
	month = {2009///},
	pages = {330 - 339},
	publisher = {Springer},
	organization = {Springer},
	chapter = {29},
	abstract = {This paper describes our efforts to use the large amounts of data available from public repositories of free, libre, and open source software (FLOSS) in our undergraduate classrooms to teach concepts that would have previously been taught using other types of data from other sources.
},
	keywords = {artificial intelligence, database, education, teaching, undergraduate, undergraduate research},
	issn = {978-3-642-02031-5},
	doi = {http://dx.doi.org/10.1007/978-3-642-02032-2_29},
	attachments = {https://flosshub.org/sites/flosshub.org/files/Using\%20FLOSS\%20Project\%20Metadata.pdf},
	author = {Squire, Megan and Duvall, Shannon}
}
@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 {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}
}
@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.}
}
@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 {534,
	title = {Analysis of Coordination Between Developers and Users in the Apache Community},
	booktitle = {OSS2008: Open Source Development, Communities and Quality (IFIP 2.13)},
	series = {IFIP International Federation for Information Processing},
	volume = {275/2008},
	year = {2008},
	month = {2008///},
	pages = {81 - 92},
	publisher = {Springer},
	organization = {Springer},
	chapter = {7},
	abstract = {Coordination is one of the keys for the success of open source software (OSS) communities because geographically distributed members need to collaborate on their work using communication tools (e.g., mailing lists, bulletin board systems, bug tracking systems, and so on). In this paper, we investigated the informal social structure among developers and users by analyzing two mailing lists of developers and users in the Apache community based on betweenness centrality, one centrality measure proposed by Freeman. From the analysis results, we found that (1) participants with high betweenness coordinated activities between developers and users and (2) some participants have been functioning as coordinators in the community for a long time.
},
	keywords = {apache, email, mailing list},
	issn = {978-0-387-09683-4},
	doi = {http://dx.doi.org/10.1007/978-0-387-09684-1_7},
	attachments = {https://flosshub.org/sites/flosshub.org/files/Analysis\%20of\%20Coordination.pdf},
	author = {Kamei, Yasutaka and Matsumoto, Shinsuke and Maeshima, Hirotaka and Onishi, Yoji and Ohira, Masao and Matsumoto, Ken-ichi}
}
@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 {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 {1209,
	title = {Computer support for discovering oss processes},
	booktitle = {3rd Workshop on Public Data about Software Development (WoPDaSD 2008)},
	year = {2008},
	month = {2008},
	pages = {31-33},
	abstract = {Large scale open source software (OSS) projects offer a wide range of documentation of the software processes that have enabled their success. Discovering these processes has been shown to be difficult to achieve.  This paper describes our experiences with providing computer support for discovering OSS processes from project data.  We discuss challenges of collecting and analyzing data from multiple types of project artifacts and how to address them. },
	keywords = {artifacts, Firefox, process management, zotero},
	attachments = {https://flosshub.org/sites/flosshub.org/files/jensen2008.pdf},
	author = {Chris Jensen and Walt Scacchi}
}
@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}
}
@conference {Gobeille:2008:FP:1370750.1370763,
	title = {The FOSSology project},
	booktitle = {Proceedings of the 2008 international working conference on Mining software repositories},
	series = {MSR {\textquoteright}08},
	year = {2008},
	month = {05/2008},
	pages = {47{\textendash}50},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {By its nature, the availability of FOSS has given computer scientists a large body of software and software projects to analyze. By having available source, version control system metadata, and open project communities, much can be learned about a software project, software development and collaborative project development. The goal of the FOSSology project is to create a public, open source software repository, together with tools to facilitate analysis, storage, and sharing of open source software and its metadata. FOSSology does license detection today.},
	keywords = {abiword, fossology, license analysis, licenses},
	isbn = {978-1-60558-024-1},
	doi = {http://doi.acm.org/10.1145/1370750.1370763},
	url = {http://doi.acm.org/10.1145/1370750.1370763},
	attachments = {https://flosshub.org/sites/flosshub.org/files/p47-gobeille.pdf},
	author = {Gobeille, Robert}
}
@article {1120,
	title = {The institutions of open source software: Examining the Debian community*},
	journal = {Information Economics and Policy},
	volume = {20},
	year = {2008},
	note = {"using primary data from its mailing lists archives, handbooks written to inform potential and actual community members, and previous analyses of institutional evolution and political conflict"

no discussion of which lists, how many, or when they were gathered...?[ms]},
	month = {12/2008},
	pages = {333 - 344},
	abstract = {Free and open source software activities involve and, perhaps, evolve institutions (rules, norms and standards) that influence the formation, growth, and demise of communities. Community institutions are attractors for some individuals while discouraging other individuals from entering or continuing to participate. Their suitability may change as a community grows. This paper examines the institutions of the Debian community where issues of community identity, distribution of authority, and decentralisation have facilitated growth and development. These same institutions have also resulted in conflicts regarding community purposes and the quality and delivery of the community{\textquoteright}s output. We examine the institutional redesign undertaken to address these problems and derive implications for F/LOS communities and companies.},
	keywords = {authority, COMMUNITY, conflict, debian, decentralization, growth, institutions, leadership},
	issn = {01676245},
	doi = {10.1016/j.infoecopol.2008.06.001},
	attachments = {https://flosshub.org/sites/flosshub.org/files/The_institutions_of_open_source_software-_IR.pdf},
	author = {Mateos Garcia, J. and Steinmueller, W.E.}
}
@conference {Schuler:2008:MUE:1370750.1370779,
	title = {Mining usage expertise from version archives},
	booktitle = {Proceedings of the 2008 international working conference on Mining software repositories},
	series = {MSR {\textquoteright}08},
	year = {2008},
	month = {05/2008},
	pages = {121{\textendash}124},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {In software development, there is an increasing need to find and connect developers with relevant expertise. Existing expertise recommendation systems are mostly based on variations of the Line 10 Rule: developers who changed a file most often have the most implementation expertise. In this paper, we introduce the concept of usage expertise, which manifests itself whenever developers are using functionality, e.g., by calling API methods. We present preliminary results for the ECLIPSE project that demonstrate that our technique allows to recommend experts for files with no or little history, identify developers with similar expertise, and measure the usage of API methods.},
	keywords = {api, computer-supported cooperative work, eclipse, expertise, recommendation, scm, software repository, source code},
	isbn = {978-1-60558-024-1},
	doi = {http://doi.acm.org/10.1145/1370750.1370779},
	url = {http://doi.acm.org/10.1145/1370750.1370779},
	attachments = {https://flosshub.org/sites/flosshub.org/files/p121-schuler.pdf},
	author = {Schuler, David and Zimmermann, Thomas}
}
@conference {Holmes:2008:NGE:1370750.1370787,
	title = {A newbie{\textquoteright}s guide to eclipse APIs},
	booktitle = {Proceedings of the 2008 international working conference on Mining software repositories},
	series = {MSR {\textquoteright}08},
	year = {2008},
	pages = {149{\textendash}152},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {Eclipse has evolved from a fledgling Java IDE into a mature software ecosystem. One of the greatest benefits Eclipse provides developers is flexibility; however, this is not without cost. New Eclipse developers often find the framework to be large and confusing. Determining which parts of the framework they should be using can be a difficult task as Eclipse documentation tends to be either very high-level, focusing on the design of the framework, or low-level, focusing on specific APIs. We have developed a tool called PopCon that provides a bridge between high-level design documentation and low-level API documentation by statically analyzing a framework and several of its clients and providing a ranked list of the relative popularity of its APIs. We have applied PopCon to the Eclipse framework for this challenge to help newbie Eclipse developers identify some of the most relevant APIs for their tasks.},
	keywords = {API popularity, documentation, eclipse, mining software repositories, module, msr challenge, PopCon, popularity},
	isbn = {978-1-60558-024-1},
	doi = {http://doi.acm.org/10.1145/1370750.1370787},
	url = {http://doi.acm.org/10.1145/1370750.1370787},
	author = {Holmes, Reid and Walker, Robert J.}
}
@conference {Rigby:2008:OSS:1368088.1368162,
	title = {Open source software peer review practices: a case study of the apache server},
	booktitle = {Proceedings of the 30th International Conference on Software Engineering (ICSE 2008)},
	series = {ICSE {\textquoteright}08},
	year = {2008},
	note = {http://faculty.salisbury.edu/~xswang/Research/Papers/SERelated/testing/p541-rigby.pdf},
	pages = {541{\textendash}550},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {Peer review is seen as an important quality assurance mechanism in both industrial development and the open source software (OSS) community. The techniques for performing inspections have been well studied in industry; in OSS development, peer reviews are less well understood. We examine the two peer review techniques used by the successful, mature Apache server project: review-then-commit and commit-then-review. Using archival records of email discussion and version control repositories, we construct a series of metrics that produces measures similar to those used in traditional inspection experiments. Specifically, we measure the frequency of review, the level of participation in reviews, the size of the artifact under review, the calendar time to perform a review, and the number of reviews that find defects. We provide a comparison of the two Apache review techniques as well as a comparison of Apache review to inspection in an industrial project. We conclude that Apache reviews can be described as (1) early, frequent reviews (2) of small, independent, complete contributions (3) conducted asynchronously by a potentially large, but actually small, group of self-selected experts (4) leading to an efficient and effective peer review technique.},
	keywords = {apache, cvs, email, inspection, mining software repositories (email), open source software, peer review, version control},
	isbn = {978-1-60558-079-1},
	doi = {10.1145/1368088.1368162},
	url = {http://doi.acm.org/10.1145/1368088.1368162},
	attachments = {https://flosshub.org/sites/flosshub.org/files/p541-rigby.pdf},
	author = {Peter C. Rigby and Daniel M. German and Storey, Margaret-Anne}
}
@conference {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}
}
@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 {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 {1001,
	title = {Identifying Changed Source Code Lines from Version Repositories},
	booktitle = {Fourth International Workshop on Mining Software Repositories (MSR{\textquoteright}07:ICSE Workshops 2007)},
	year = {2007},
	pages = {14 - 14},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Minneapolis, MN, USA},
	abstract = {Observing the evolution of software systems at different levels of granularity has been a key issue for a number of studies, aiming at predicting defects or at studying certain phenomena, such as the presence of clones or of crosscutting concerns. Versioning systems such as CVS and SVN, however, only provide information about lines added or deleted by a contributor: any change is shown as a sequence of additions and deletions. This provides an erroneous estimate of the amount of code changed.

This paper shows how the evolution of changes at source code line level can be inferred from CVS repositories, by combining information retrieval techniques and the Levenshtein edit distance. The application of the proposed approach to the ArgoUML case study indicates a high precision and recall.},
	keywords = {argouml, cvs, levenshtein, scm, source code},
	isbn = {0-7695-2950-X},
	doi = {10.1109/MSR.2007.14},
	attachments = {https://flosshub.org/sites/flosshub.org/files/28300014.pdf},
	author = {Canfora, Gerardo and Cerulo, Luigi and Di Penta, Massimiliano}
}
@conference {995,
	title = {Open Borders? Immigration in Open Source Projects},
	booktitle = {Fourth International Workshop on Mining Software RepositoriesFourth International Workshop on Mining Software Repositories (MSR{\textquoteright}07:ICSE Workshops 2007)},
	year = {2007},
	pages = {6 - 6},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Minneapolis, MN, USA},
	abstract = {Open source software is built by teams of volunteers. Each project has a core team of developers, who have the authority to commit changes to the repository; this team is the elite, committed foundation of the project, selected through a meritocratic process from a larger number of people who participate on the mailing list. Most projects carefully regulate admission of outsiders to full developer privileges; some projects even have formal descriptions of this process. Understanding the factors that influence the "who, how and when" of this process is critical, both for the sustainability of FLOSS projects, and for outside stakeholders who want to gain entry and succeed. In this paper we mount a quantitative case study of the process by which people join FLOSS projects, using data mined from the Apache web server, Postgres, and Python. We develop a theory of open source project joining, and evaluate this theory based on our data.},
	keywords = {apache, core, joining, postgresql, python, team},
	isbn = {0-7695-2950-X},
	doi = {10.1109/MSR.2007.23},
	attachments = {https://flosshub.org/sites/flosshub.org/files/28300006.pdf},
	author = {Christian Bird and Gourley, Alex and Devanbu, Prem and Swaminathan, Anand and Hsu, Greta}
}
@conference {993,
	title = {Spam Filter Based Approach for Finding Fault-Prone Software Modules},
	booktitle = {Fourth International Workshop on Mining Software Repositories (MSR{\textquoteright}07:ICSE Workshops 2007)},
	year = {2007},
	pages = {4 - 4},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Minneapolis, MN, USA},
	abstract = {Because of the increase of needs for spam e-mail detection, the spam filtering technique has been improved as a convenient and effective technique for text mining. We propose a novel approach to detect fault-prone modules in a way that the source code modules are considered as text files and are applied to the spam filter directly. In order to show the applicability of our approach, we conducted experimental applications using source code repositories of Java based open source developments. The result of experiments shows that our approach can classify more than 75\% of software modules correctly.},
	keywords = {argouml, bug reports, classification, eclipse, java, modules, scm, spam, text mining},
	isbn = {0-7695-2950-X},
	doi = {10.1109/MSR.2007.29},
	attachments = {https://flosshub.org/sites/flosshub.org/files/28300004.pdf},
	author = {Mizuno, Osamu and Ikami, Shiro and Nakaichi, Shuya and Kikuno, Tohru}
}
@conference {1002,
	title = {Studying Versioning Information to Understand Inheritance Hierarchy Changes},
	booktitle = {Fourth International Workshop on Mining Software Repositories (MSR{\textquoteright}07:ICSE Workshops 2007)},
	year = {2007},
	pages = {16 - 16},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Minneapolis, MN, USA},
	abstract = {With the widespread adoption of object-oriented programming, changing the inheritance hierarchy became an inherent part of today{\textquoteright}s software maintenance activities. Unfortunately, little is known about the "state-of-the-practice" with respect to changing an application{\textquoteright}s inheritance hierarchy, and consequently we do not know how the change process can be improved. In this paper, we report on a study of the hierarchy changes stored in a versioning system to explore the answers to three research questions: (1) why are hierarchy changes made? (2) what kind of hierarchy changes are made? (3) what is the impact of these changes? Based on the results of this study, we formulate 7 hypotheses which should be investigated further to make conclusive interpretations on how hierarchy changes fit in the actual change process.},
	keywords = {argouml, change management, inheritance, jedit},
	isbn = {0-7695-2950-X},
	doi = {10.1109/MSR.2007.30},
	attachments = {https://flosshub.org/sites/flosshub.org/files/28300016.pdf},
	author = {Rysselberghe, Filip Van and Demeyer, Serge}
}
@conference {1008,
	title = {What Can OSS Mailing Lists Tell Us? A Preliminary Psychometric Text Analysis of the Apache Developer Mailing List},
	booktitle = {Fourth International Workshop on Mining Software Repositories (MSR{\textquoteright}07:ICSE Workshops 2007)},
	year = {2007},
	pages = {23 - 23},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Minneapolis, MN, USA},
	abstract = {Developer mailing lists are a rich source of information about Open Source Software (OSS) development. The unstructured nature of email makes extracting information difficult. We use a psychometrically-based linguistic analysis tool, the LIWC, to examine the Apache httpd server developer mailing list. We conduct three preliminary experiments to assess the appropriateness of this tool for information extraction from mailing lists. First, using LIWC dimensions that are correlated with the big five personality traits, we assess the personality of four top developers against a baseline for the entire mailing list. The two developers that were responsible for the major Apache releases had similar personalities. Their personalities were different from the baseline and the other developers. Second, the first and last 50 emails for two top developers who have left the project are examined. The analysis shows promise in understanding why developers join and leave a project. Third, we examine word usage on the mailing list for two major Apache releases. The differences may reflect the relative success of each release.},
	keywords = {apache, developers, email, joining, liwc, mailing lists, personality},
	isbn = {0-7695-2950-X},
	doi = {10.1109/MSR.2007.35},
	attachments = {https://flosshub.org/sites/flosshub.org/files/28300023.pdf},
	author = {Peter C. Rigby and Hassan, Ahmed E.}
}
@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 {WeiBgerber:2006:RLE:1137983.1138011,
	title = {Are refactorings less error-prone than other changes?},
	booktitle = {Proceedings of the 2006 international workshop on Mining software repositories},
	series = {MSR {\textquoteright}06},
	year = {2006},
	pages = {112{\textendash}118},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {Refactorings are program transformations which should preserve the program behavior. Consequently, we expect that during phases when there are mostly refactorings in the change history of a system, only few new bugs are introduced. For our case study we analyzed the version histories of several open source systems and reconstructed the refactorings performed. Furthermore, we obtained bug reports from various sources depending on the system. Based on this data we identify phases when the above hypothesis holds and those when it doesn{\textquoteright}t.},
	keywords = {argouml, bug reports, bugs, change history, jedit, junit, re-engineering, refactoring, reverse engineering, software evolution, version control},
	isbn = {1-59593-397-2},
	doi = {http://doi.acm.org/10.1145/1137983.1138011},
	url = {http://doi.acm.org/10.1145/1137983.1138011},
	attachments = {https://flosshub.org/sites/flosshub.org/files/112AreRefactorings.pdf},
	author = {Wei{\ss}gerber, Peter and Diehl, Stephan}
}
@conference {Gurbani:2006:CSC:1134285.1134352,
	title = {A case study of a corporate open source development model},
	booktitle = {Proceedings of the 28th international conference on Software engineering},
	series = {ICSE {\textquoteright}06},
	year = {2006},
	pages = {472{\textendash}481},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {Open source practices and tools have proven to be highly effective for overcoming the many problems of geographically distributed software development. We know relatively little, however, about the range of settings in which they work. In particular, can corporations use the open source development model effectively for software projects inside the corporate domain? Or are these tools and practices incompatible with development environments, management practices, and market-driven schedule and feature decisions typical of a commercial software house? We present a case study of open source software development methodology adopted by a significant commercial software project in the telecommunications domain. We extract a number of lessons learned from the experience, and identify open research questions.},
	keywords = {architecture, case study, open source, session initiation protocol, software development, vkg},
	isbn = {1-59593-375-1},
	doi = {10.1145/1134285.1134352},
	url = {http://doi.acm.org/10.1145/1134285.1134352},
	author = {Gurbani, Vijay K. and Garvert, Anita and Herbsleb, James D.}
}
@conference {Beyer:2006:CVA:1137983.1138023,
	title = {Co-change visualization applied to PostgreSQL and ArgoUML: (MSR challenge report)},
	booktitle = {Proceedings of the 2006 international workshop on Mining software repositories},
	series = {MSR {\textquoteright}06},
	year = {2006},
	pages = {165{\textendash}166},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {Co-change visualization is a method to recover the subsystem structure of a software system from the version history, based on common changes and visual clustering. This paper presents the results of applying the tool CCVisu which implements co-change visualization, to the two open-source software systems PostgreSQL and ArgoUML The input of the method is the co-change graph, which can be easily extracted by CCVisu from a Cvs version repository. The output is a graph layout that places software artifacts that were often commonly changed at close positions, and artifacts that were rarely co-changed at distant positions. This property of the layout is due to the clustering property of the underlying energy model,which evaluates the quality of a produced layout. The layout can be displayed on the screen, or saved to a file in SVG or VRML format.},
	keywords = {argouml, ccvisu, cvs, force-directed graph layout, graph, mining challenge, msr challenge, postgresql, software clustering, software structure analysis, software visualization, version control, visualization},
	isbn = {1-59593-397-2},
	doi = {http://doi.acm.org/10.1145/1137983.1138023},
	url = {http://doi.acm.org/10.1145/1137983.1138023},
	attachments = {https://flosshub.org/sites/flosshub.org/files/165Co-Change.pdf},
	author = {Beyer, Dirk}
}
@conference {682,
	title = {Collaborative Maintenance in Large Open-Source Projects},
	booktitle = {OSS2006: Open Source Systems (IFIP 2.13)},
	series = {IFIP International Federation for Information Processing},
	year = {2006},
	pages = {233 - 244},
	publisher = {Springer},
	organization = {Springer},
	abstract = {The paper investigates collaborative work among maintainers of open source software by analyzing the logs of a set of 10 large projects. We inquire whether teamwork can be influenced by several characteristics of code. Preliminary results suggest that collaboration among maintainers in most large open-source projects seems to be positively influenced by file vintage and by Halstead volume of files, and negatively by McCabe complexity and size measured in SLOCs. These results could be consistent with an increased attractivity of files created early in the history of a project, and with maintainers being less attracted by more verbose code and by more complex code, although in this last case it might also reflect the fact that more complex files would be de facto more exclusive in terms of maintenance.
},
	keywords = {apache, COLLABORATION, complexity, cvs, gaim, gcc, ghostscript, halstead, lines of code, loc, mccabe, mozilla, netbsd, openssh, postgresql, python, sloc},
	doi = {http://dx.doi.org/10.1007/0-387-34226-5_23},
	attachments = {https://flosshub.org/sites/flosshub.org/files/Collaborative\%20Maintenance.pdf},
	author = {den Besten, Matthijs and Jean-Michel Dalle and Galia, Fabrice}
}
@conference {683,
	title = {Communication Networks in an Open Source Software Project},
	booktitle = {OSS2006: Open Source Systems (IFIP 2.13)},
	series = {IFIP International Federation for Information Processing },
	volume = {203/2006},
	year = {2006},
	month = {2006///},
	pages = {297 - 306},
	publisher = {Springer},
	organization = {Springer},
	abstract = {This study explores the nature of the social network and the patterns of communication that exist in an open source software development project, the Apache HTTP (WEB) server project. Our analysis of archival data on email communications between developers in the Apache HTTP server project suggests an interesting pattern of communication. We find that the core developers self-organize into three sub-groups that communicate intensely in completing the project. Our analysis also reveals that a few prominent developers who are centrally located in the network are driving communications within the project. We identify the implications of our findings and suggest areas for further research.
},
	keywords = {apache, core, developers, email, email archive, mailing list, participation, social network analysis},
	issn = {978-0-387-34225-2},
	doi = {http://dx.doi.org/10.1007/0-387-34226-5_30},
	attachments = {https://flosshub.org/sites/flosshub.org/files/Communication\%20Networks\%20in\%20an\%20Open\%20Source.pdf},
	author = {Roberts, Jeffrey and Il-Horn Hann and Sandra Slaughter}
}
@conference {686,
	title = {Contributor Turnover in Libre Software Projects},
	booktitle = {OSS2006: Open Source Systems (IFIP 2.13)},
	series = {IFIP International Federation for Information Processing},
	year = {2006},
	pages = {273 - 286},
	publisher = {Springer},
	organization = {Springer},
	abstract = {A common problem that management faces in software companies is the high instability of their staff. In libre (free, open source) software projects, the permanence of developers is also an open issue, with the potential of causing problems amplified by the self-organizing nature that most of them exhibit. Hence, human resources in libre software projects are even more difficult to manage: developers are in most cases not bound by a contract and, in addition, there is not a real management structure concerned about this problem. This raises some interesting questions with respect to the composition of development teams in libre software projects, and how they evolve over time. There are projects lead by their original founders (some sort of {\textquotedblleft}code gods{\textquotedblright}), while others are driven by several different developer groups over time (i.e. the project {\textquotedblleft}regenerates{\textquotedblright} itself). 
In this paper, we propose a quantitative methodology, based on the analysis of the activity in the source code management repositories, to study how these processes (developers leaving, developers joining) affect libre software projects. The basis of it is the analysis of the composition of the core group, the group of developers most active in a project, for several time lapses. We will apply this methodology to several large, well-known libre software projects, and show how it can be used to characterize them. In addition, we will discuss the lessons that can be learned, and the validity of our proposal.
},
	keywords = {apache, committers, core, cvs, cvsanaly, developers, evolution, freebsd, gimp, gnome, kde, mono, mozilla},
	doi = {http://dx.doi.org/10.1007/0-387-34226-5_28},
	attachments = {https://flosshub.org/sites/flosshub.org/files/Contributor\%20Turnover\%20in\%20Libre\%20Software\%20Projects.pdf},
	author = {Gregorio Robles and Gonzalez-Barahona, Jesus}
}
@conference {689,
	title = {Evolution of Open Source Communities},
	booktitle = {OSS2006: Open Source Systems (IFIP 2.13)},
	series = {IFIP International Federation for Information Processing},
	year = {2006},
	note = {"we took snapshots of its membership at regular intervals"
"we chose a one year period"
"we retrieve the list of core developers ordered by their number of inbound messages, as noted above."},
	pages = {21 - 32},
	publisher = {Springer},
	organization = {Springer},
	abstract = {The goal of this paper is to document the evolution of a portfolio of related open source communities over time. As a case study, we explore the subprojects of the Apache project, one of the largest and most visible open source projects. We extract the community structure from the mailing list data, and study how the subcommunities evolve, and are interrelated over time. Our analysis leads us to propose the following hypotheses about the growth of open source communities: (1) communities add new developers by a process of preferential attachment; (2) links between existing communities are also subject to preferential attachment; (3) developers will migrate between communities together with other collaborators; and (4) information flow follows project dependencies. In particular, we are concerned with the underlying factors that motivate the migration between communities, such as information flow, co-worker ties, and project dependencies.
},
	keywords = {apache, COMMUNITY, core, developers, email, email archives, mailing list, membership},
	doi = {http://dx.doi.org/10.1007/0-387-34226-5_3},
	attachments = {https://flosshub.org/sites/flosshub.org/files/Evolution\%20of\%20Open\%20Source\%20Communities.pdf},
	author = {Weiss, Michael and Moroiu, Gabriella and Zhao, Ping}
}
@conference {Canfora:2006:FGI:1137983.1138009,
	title = {Fine grained indexing of software repositories to support impact analysis},
	booktitle = {Proceedings of the 2006 international workshop on Mining software repositories},
	series = {MSR {\textquoteright}06},
	year = {2006},
	pages = {105{\textendash}111},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {Versioned and bug-tracked software systems provide a huge amount of historical data regarding source code changes and issues management. In this paper we deal with impact analysis of a change request and show that data stored in software repositories are a good descriptor on how past change requests have been resolved. A fine grained analysis method of software repositories is used to index code at different levels of granularity, such as lines of code and source files, with free text contained in software repositories. The method exploits information retrieval algorithms to link the change request description and code entities impacted by similar past change requests. We evaluate such approach on a set of three open-source projects.},
	keywords = {argouml, change analysis, Firefox, gedit, impact analysis, mining software repositories, scm, source code, version control},
	isbn = {1-59593-397-2},
	doi = {http://doi.acm.org/10.1145/1137983.1138009},
	url = {http://doi.acm.org/10.1145/1137983.1138009},
	attachments = {https://flosshub.org/sites/flosshub.org/files/105FineGrained.pdf},
	author = {Canfora, Gerardo and Cerulo, Luigi}
}
@conference {691,
	title = {From Individual Contribution to Group Learning},
	booktitle = {OSS2006: Open Source Systems (IFIP 2.13)},
	series = {IFIP International Federation for Information Processing},
	year = {2006},
	pages = {77 - 90},
	publisher = {Springer},
	organization = {Springer},
	abstract = {Open Source Software (OSS) groups experience many benefits and challenges with respect to the core group{\textquoteright}s effectiveness. In order to capitalize on the benefits and minimize the challenges, OSS groups must learn not only on the individual level, but also on the group level. OSS groups learn by integrating individual contributions into the group{\textquoteright}s product and processes.
This paper reports on the characteristics of the learning process in OSS groups. The study utilized an embedded single case study design that observed and analyzed group learning processes in the Apache Web server OSS project. The study used learning opportunity episodes (LOE) as the embedded unit of analysis and developed and utilized three content analytic schemes to describe the characteristics of the learning process and the factors affecting this process.
},
	keywords = {apache, case study},
	doi = {http://dx.doi.org/10.1007/0-387-34226-5_8},
	attachments = {https://flosshub.org/sites/flosshub.org/files/From\%20Individual\%20Contribution\%20to\%20Group\%20Learning.pdf},
	author = {Hala Annabi and Kevin Crowston and Robert Heckman}
}
@article {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}
}
@conference {Kim:2006:LDT:1137983.1138027,
	title = {How long did it take to fix bugs?},
	booktitle = {Proceedings of the 2006 international workshop on Mining software repositories},
	series = {MSR {\textquoteright}06},
	year = {2006},
	pages = {173{\textendash}174},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {The number of bugs (or fixes) is a common factor used to measure the quality of software and assist bug related analysis. For example, if software files have many bugs, they may be unstable. In comparison, the bug-fix time--the time to fix a bug after the bug was introduced--is neglected. We believe that the bug-fix time is an important factor for bug related analysis, such as measuring software quality. For example, if bugs in a file take a relatively long time to be fixed, the file may have some structural problems that make it difficult to make changes. In this report, we compute the bug-fix time of files in ArgoUML and PostgreSQL by identifying when bugs are introduced and when the bugs are fixed. This report includes bug-fix time statistics such as average bug-fix time, and distributions of bug-fix time. We also list the top 20 bug-fix time files of two projects.},
	keywords = {argouml, bug fixing, bugs, mining challenge, msr challenge, postgresql, quality, time},
	isbn = {1-59593-397-2},
	doi = {http://doi.acm.org/10.1145/1137983.1138027},
	url = {http://doi.acm.org/10.1145/1137983.1138027},
	attachments = {https://flosshub.org/sites/flosshub.org/files/173HowLong.pdf},
	author = {Kim, Sunghun and Whitehead,Jr., E. James}
}
@conference {697,
	title = {Life cycle of Defects in Open Source Software Projects},
	booktitle = {OSS2006: Open Source Systems (IFIP 2.13)},
	series = {IFIP International Federation for Information Processing},
	year = {2006},
	note = {"we collected and analyzed defects of the apache http server and mozilla firefox" 
"all the defects reported between X and X were analyzed"},
	pages = {195 - 200},
	publisher = {Springer},
	organization = {Springer},
	abstract = {We studied the maintenance process from the viewpoint of defect management and the defect life cycle. First, we outline a model for the defect life cycle based on ISO/IEC standards, the Framework for Open Source maintenance process, and the Bugzilla defect management system. Thereafter, we analyze defects from two Open Source software projects. The aim of the study was support the maintenance reliability. However, we found that most of the defects did not follow the life-cycle model. Defects were usually directly resolved from initial state without being assigned.
},
	keywords = {apache, defects, Firefox, mozilla},
	doi = {http://dx.doi.org/10.1007/0-387-34226-5_19},
	attachments = {https://flosshub.org/sites/flosshub.org/files/Life\%20cycle\%20of\%20Defects\%20in\%20OSS\%20Projects.pdf},
	author = {Koponen, Timo}
}
@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 {WeiBgerber:2006:MRA:1137983.1138028,
	title = {Mining refactorings in ARGOUML},
	booktitle = {Proceedings of the 2006 international workshop on Mining software repositories},
	series = {MSR {\textquoteright}06},
	year = {2006},
	note = {"To see if refactorings in ARGOUML have an effect on the occurrence of new bugs and on communication between the developers, we relate the refactorings to bug reports in ISSUEZILLA respectively to mails on the developer mailing list. "},
	pages = {175{\textendash}176},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {In this paper we combine the results of our refactoring reconstruc- tion technique with bug, mail and release information to perform process and bug analyses of the ARGOUML CVS archive.},
	keywords = {argouml, bug tracking, bugs, cvs, email, evolution, mining challenge, msr challenge, re-engineering, refactoring, release history},
	isbn = {1-59593-397-2},
	doi = {http://doi.acm.org/10.1145/1137983.1138028},
	url = {http://doi.acm.org/10.1145/1137983.1138028},
	attachments = {https://flosshub.org/sites/flosshub.org/files/175MiningRefactorings.pdf},
	author = {Wei{\ss}gerber, Peter and Diehl, Stephan and G{\"o}rg, Carsten}
}
@conference {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 {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 {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.}
}
@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 {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}
}
@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}
}
@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 {787,
	title = {Knowledge, Communication and Innovation: the case of Open Source Software as Open Media},
	booktitle = {OSS2005: Open Source Systems },
	year = {2005},
	pages = {314-316},
	abstract = {The understanding of the major characteristics of Linux Operative System and, more in general, the analysis of the so-called Open Source Phenomenon, is nowadays a central issue in order to appreciate the ongoing evolution of software industry. Free/Open Source Software model may appears a {\textquotedblleft}revolution{\textquotedblright} in the way of thinking about software development, distribution and use. But, at a closer glance, it reveals itself more as an {\textquotedblleft}evolution{\textquotedblright} along the path of {\textquotedblleft}tinkering with software{\textquotedblright} typical of the Hacker Tech-Culture since the beginning of sixties. In fact the {\textquotedblleft}open source way{\textquotedblright} of developing software results from the hackers habit of sharing technological knowledge and it represents a perfection of this, due to the availably of new communication technologies. The aim of this research is to explain this evolution, to point out its historical, economics and technological determinants and to link it with the evolution of the {\textquotedblleft}communicational medium{\textquotedblright} used by the open source ...},
	keywords = {attributive, Creative Commons, non-commercial},
	url = {http://pascal.case.unibz.it/handle/2038/972},
	author = {Lorenzo Benussi}
}
@conference {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 {Huang:2005:MVH:1083142.1083158,
	title = {Mining version histories to verify the learning process of Legitimate Peripheral Participants},
	booktitle = {Proceedings of the 2005 international workshop on Mining software repositories},
	series = {MSR {\textquoteright}05},
	year = {2005},
	pages = {84-88},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {Since code revisions reflect the extent of human involvement in the software development process, revision histories reveal the interactions and interfaces between developers and modules.We therefore divide developers and modules into groups according to the revision histories of the open source software repository, for example, sourceforge.net. To describe the interactions in the open source development process, we use a representative model, Legitimate Peripheral Participation (LPP) [6], to divide developers into groups such as core and peripheral teams, based on the evolutionary process of learning behavior.With the conventional module relationship, we divide modules into kernel and non-kernel types (such as UI). In the past, groups of developers and modules have been partitioned naturally with informal criteria. In this work, however, we propose a developer-module relationship model to analyze the grouping structures between developers and modules. Our results show some process cases of relative importance on the constructed graph of project development. The graph reveals certain subtle relationships in the interactions between core and non-core team developers, and the interfaces between kernel and non-kernel modules.},
	keywords = {awstats, bzflag, cvs, filezilla, gallery, Legitimate Peripheral Participants (LPP), moodle, open boundary, open source software development process, phpmyadmin, social networks, sourceforge},
	isbn = {1-59593-123-6},
	doi = {http://doi.acm.org/10.1145/1082983.1083158},
	url = {http://doi.acm.org/10.1145/1082983.1083158},
	attachments = {https://flosshub.org/sites/flosshub.org/files/84MiningVersion.pdf},
	author = {Huang, Shih-Kun and Liu, Kang-min}
}
@conference {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 {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 {782,
	title = {Towards Supporting Agile Practice Within The Libre Software Paradigm},
	booktitle = {OSS2005: Open Source Systems },
	year = {2005},
	pages = {303-304},
	abstract = {Individual agile methods have never been practiced as defined, in the same way that Royce{\textquoteright}s waterfall [1] model never reflected actual practice. Instead, practitioners adapted the core principles of these processes in order to suit their needs. Understanding this is key to appreciating the agile mindset. What does exist is a set of principles1 which, when followed loosely, form the agile practices. It is an important part of the agile mentality that the individuals within a project are more important that the process they follow. However, the individual methods do have their own identifying features that make them unique; for example testing must be performed before coding within eXtreme Programming (XP) [2]. However, if practitioners were to apply XP, exactly as Beck describes it, then they are probably not {\textquotedblleft}doing agile{\textquotedblright} as they may not be following the process that suits their needs best. One of the interesting features of the XP method is its requirement of a collocated team. Th...},
	keywords = {agile methods, agile practice, extreme programming, libre software, open source, XP},
	url = {http://pascal.case.unibz.it/handle/2038/1546},
	author = {Adams, Paul and Boldyreff, Cornelia}
}
@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}
}
@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}
}
@conference {1052,
	title = {Bug driven bug finders},
	booktitle = {Proceedings of the 2004 international workshop on Mining software repositories  - MSR {\textquoteright}04},
	volume = {2004},
	year = {2004},
	pages = {70 - 74},
	publisher = {IEE},
	organization = {IEE},
	address = {Edinburgh, Scotland, UK},
	abstract = {We describe a method of creating tools to find bugs in software that is driven by the analysis of previously fixed bugs. We present a study of bug databases and software repositories that characterize commonly occurring types of bugs.	Based on the types of bugs that were commonly reported and fixed in the code, we determine what types of bug finding tools should be developed. We have implemented one static checker, a return value usage checker. Novel features of this checker include the use of information from the software repository to try to improve its false positive rate by identifying patterns that have resulted in previous bug fixes.},
	keywords = {apache, bug tracking, bugs},
	doi = {10.1049/ic:20040479},
	attachments = {https://flosshub.org/sites/flosshub.org/files/70BugDrivenBug.pdf},
	author = {Williams, C.C. and Hollingsworth, J.K.}
}
@proceedings {1188,
	title = {Communication and Conflict Issues in Collaborative Software Research Projects},
	year = {2004},
	pages = {14-17},
	abstract = {The Open Source Component Artefact Repository (OSCAR) was developed under the auspices of the GENESIS project to store data produced during the software development process. Significant problems were encountered during the course of the project in both the development itself and management of the project. The reasons for and potential solutions to these problems are examined with the intention of developing a set of guidelines to enable participants in other collaborative projects to avoid these pitfalls.
We wish to make it clear that we attach no opprobrium to any of the participants in the GENESIS project as many of the issues we outline below have solutions only visible with hindsight. Instead, we seek to provide a fair-minded critique of our role and the mistakes we made in a fairly typical two-year EU research project, and to provide a set of recommendations for other similar projects, in order that they can (attempt to) avoid suffering similarly.},
	keywords = {artefact, cvs, genesis, oscar},
	attachments = {https://flosshub.org/sites/flosshub.org/files/boldyreff15-18.pdf},
	author = {Boldyreff, Cornelia and Nutter, David and Rank, Stephen}
}
@proceedings {1190,
	title = {Community structure of modules in the Apache project},
	year = {2004},
	pages = {44-48},
	abstract = {The relationships among modules in a software project of a certain size can give us much information about its internal organization and a way to control and monitor development activities and evolution of large libre software projects. In this paper, we show how information available in CVS repositories can be used to study the structure of the modules in a project when they are related by the people working in them, and how techniques taken from the social networks fields can be used to highlight the characteristics of that structure. As a case example, we also show some results of applying this methodology to the Apache project in several points in time. Among other facts, it is shown how the project evolves and is self-structuring, with developer communities of modules corresponding to semantically related families of modules.},
	keywords = {apache, cvs, source code},
	attachments = {https://flosshub.org/sites/flosshub.org/files/gonzalezBarahona44-48.pdf},
	author = {Jesus M. Gonzalez-Barahona and Luis Lopez and Gregorio Robles}
}
@conference {Crowston:2004,
	title = {Coordination practices for bug fixing within FLOSS development teams},
	booktitle = {1st International Workshop on Computer Supported Activity Coordination, 6th International Conference on Enterprise Information Systems},
	year = {2004},
	note = {"First, we chose projects for which data we need for our analysis are publicly available (not all projects allow public access to the bug tracking system). Second, we chose teams with more than 8 members...we tried to select more and less suc- cessful development teams. To this aim we used the definitions of success proposed by [9], who suggest that a project is successful if it is active, the resulting software is downloaded and used and the code matures"

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

"We collected data indicative of the success of each project, such as its level of activity, number of downloads and development status. We then collected data from the archives of the bug tracking system, the tool used to support the bug fixing process"},
	address = {Porto, Portugal},
	abstract = {Free/Libre Open Source Software (FLOSS) is primarily developed by distributed teams. Developers contribute from around the world and coordinate their activity almost exclusively by means of email and bulletin boards. FLOSS development teams some how profit from the advantages and evade the challenges of distributed software development. Despite the relevance of the FLOSS both for research and practice, few studies have investigated the work practices adopted by these development teams. In this paper we investigate the structure and the coordination practices adopted by development teams during the bug-fixing process, which is considered one of main areas of FLOSS project success. In particular, based on a codification of the messages recorded in the bug tracking system of four projects, we identify the accomplished tasks, the adopted coordination mechanisms, and the role undertaken by both the FLOSS development team and the FLOSS community. We conclude with suggestions for further research.},
	keywords = {activity, bug fixing, bug reports, bug tracker, coordination, downloads, dynapi, FLOSS, gaim, kicq, phpmyadmin, status},
	attachments = {https://flosshub.org/sites/flosshub.org/files/CrowstonScozzi04coordination.pdf},
	author = {Kevin Crowston and Barbara Scozzi}
}
@conference {Xinyi04fourinteresting,
	title = {Four Interesting Ways in Which History Can Teach Us About Software},
	booktitle = {Proceedings of the 2004 international workshop on Mining software repositories  - MSR {\textquoteright}04},
	year = {2004},
	month = {05/2004},
	pages = {58-62},
	abstract = {In this position paper, we outline four kinds of studies that we have undertaken in trying to understand various aspects of a software system{\textquoteright}s evolutionary history. In each instance, the studies have involved detailed examination of real software systems based on {\textquotedblleft}facts{\textquotedblright} extracted from various kinds of source artifact repositories, as well as the development of accompanying tools to aid in the extraction, abstraction, and comprehension processes. We briefly discuss the goals, results, and methodology of each approach.},
	keywords = {ant, apache, change analysis, clone, clone detection, cvs, evolution, gcc, growth, kepler, linux, midworld, mycore, postgresql, source code, version control},
	attachments = {https://flosshub.org/sites/flosshub.org/files/58FourInterestingWays.pdf},
	author = {Michael Godfrey and Xinyi Dong and Cory Kapser and Lijie Zou}
}
@proceedings {1186,
	title = {How can Academic Software Research and Open Source Software Development help each other?},
	year = {2004},
	pages = {5-8},
	abstract = {In this paper we discuss a few issues faced in coordinating, managing and implementing academic software research projects and suggest how some of these issues can be addressed by adopting tools and processes from Open Source Software Development. At the same time we also discuss how a few issues in Open Source Software Development (OSSD) projects can be addressed by adopting processes from Academic Software Research.},
	keywords = {academic, education},
	attachments = {https://flosshub.org/sites/flosshub.org/files/ambati6-9.pdf},
	author = {Ambati, V. and Kishore, S.P.}
}
@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.}
}
@article {DBLP:journals/electronicmarkets/Joode04,
	title = {Managing Conflicts in Open Source Communities},
	journal = {Electronic Markets},
	volume = {14},
	number = {2},
	year = {2004},
	pages = {104-113},
	abstract = {An increasing number of companies adopt open source software. These companies will typically pay programmers to participate in the design, development and maintenance of open source software. The programmers, however, are reported to have different interests compared to the voluntary programmers who dominate most open source communities. The diversity of interest will inevitably result in conflicts. To ensure that their interests are achieved, companies should understand how conflicts between their programmers and the voluntary programmers can be managed. The aim of this paper is to identify and discuss mechanisms that are currently present to manage conflicts in open source communities.

The mechanisms identified in this paper are based on an explorative literature study and on 48 semi-structured interviews with programmers from a variety of open source communities. Four mechanisms have been identified and their relevance in the management of conflicts are discussed. They are: third-party intervention; modularity; parallel software development lines; and the exit option. The paper ends with an example of Covalent, which deploys parallel software development lines to manage conflicts in the Apache community. },
	keywords = {abiword, apache, conflict, covalent, interviews, organizational sponsorship, Volunteers},
	author = {Ruben van Wendel de Joode}
}
@article {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 {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 {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}
}
@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 {1116,
	title = {Organizational learning in open-source software projects: an analysis of debugging data},
	journal = {IEEE Transactions on Engineering Management},
	volume = {50},
	year = {2003},
	month = {11/2003},
	pages = {485 - 493},
	abstract = {This paper studies organizational learning effects in open-source programming projects. Working with data from the Apache and Mozilla projects, the study focuses on three aspects of open-source development. The first is the use of the open-source approach as a hedge against system complexity. The second is the adaptive learning mechanisms realized by the debugging process. The last is the learning curve effects of project-specific experience on bug cycle times. The results indicate that while open-source development is subject to positive learning effects, these effects are not universal, with some projects deriving more benefit than others.},
	keywords = {apache, bugs, complexity, mozilla},
	issn = {0018-9391},
	doi = {10.1109/TEM.2003.820136},
	author = {Huntley, C.L.}
}
@conference {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 {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 {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}
}
@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 {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}
}
@conference {1162,
	title = {Is Open Source Software Development Faster, Better, and Cheaper than Software Engineering?},
	booktitle = {Proceedings of the 2nd ICSE Workshop on Open Source},
	year = {2002},
	abstract = {In this paper, I draw attention to the question of determining how open source software development may represent a significant alternative to modern software engineering techniques for developing large-scale software systems. OSSD often entails shorter time frames, producing higher quality systems, and incurring lower costs than may be realized through developing systems according SE techniques. Understanding why and how this may arise is the focus of this paper.},
	keywords = {argouml, quality, tigris},
	attachments = {https://flosshub.org/sites/flosshub.org/files/Scacchi_0.pdf},
	author = {Walt Scacchi}
}
@conference {1152,
	title = {Open-Source Artefact Management},
	booktitle = {2nd Workshop on Open Source Software Engineering at ICSE 2002},
	year = {2002},
	abstract = {This paper presents the GENESIS project, which aims to develop an open-source, lightweight, process-aware (and process-neutral) workflow management system. In particular OSCAR, the artefact repository is discussed. The requirements of a system for artefact management and storage are described, and the concept of active artefacts is explained. The software engineering methods which will be used in the project are described, and some examples of the open-source tools which may be used are described.},
	keywords = {artefacts, artifacts, genesis, oscar, workflow},
	attachments = {https://flosshub.org/sites/flosshub.org/files/BoldyreffNutterRank.pdf},
	author = {Boldyreff, Cornelia and Nutter, David and Rank, Stephen}
}
@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 {1157,
	title = {Why Do Developers Contribute to Open Source Projects? First Evidence of Economic Incentives},
	booktitle = {Proceedings of the 2nd ICSE Workshop on Open Source},
	year = {2002},
	note = {"The data for this research come from two primary sources: Apache project archives and a targeted survey of Apache participants. Archival data are open source project artifacts such as email and source code archives, source code version control meta-data and developer web sites."},
	abstract = {The availability of commercial quality, free software products such as the Apache HTTP (web) server or the Linux operating system has focused significant attention on the open source development process by which these products were created. One of the more perplexing aspects of open source software projects is why developers freely devote their time and energy to these projects. While many open source participants cite idealistic motives for participation, Lerner and Tirole (2000) argue that developer participation in open source projects may, in part, be explained by existing economic theory regarding career concerns. This research seeks to confirm or disconfirm the existence of economic returns to participation in open source development. Preliminary results of our empirical investigation suggest that greater open source participation per se, as measured in contributions made, does not lead to wage increases. However, a higher status in a merit-based ranking within the Apache Project does lead to significantly higher wages. This suggests that employers do not reward the gain in experience through open source participation as an increase in human capital. The results are also consistent with the notion that a high rank within the Apache Software Foundation is a credible signal of the productive capacity of a programmer.},
	keywords = {apache, contributions, cvs, developers, ECONOMICS, email, email archives, financial, Human capital, mailing list, MOTIVATION, participation, source code, version control},
	attachments = {https://flosshub.org/sites/flosshub.org/files/HannRobertsSlaughterFielding.pdf},
	author = {Il-Horn Hann and Jeff Roberts and Sandra Slaughter and Roy Fielding}
}
@conference {1159,
	title = {Why Not Improve Coordination in Distributed Software Development by Stealing Good Ideas from Open Source?},
	booktitle = {Proceedings of the 2nd ICSE Workshop on Open Source},
	year = {2002},
	keywords = {apache, communication, coordination, distributed},
	attachments = {https://flosshub.org/sites/flosshub.org/files/MockusHerbsleb.pdf},
	author = {Audris Mockus and Herbsleb, James}
}
@conference {1138,
	title = {Creating a Free, Dependable Software Engineering Environment for Building Java Applications},
	booktitle = {1st Workshop on Open Source Software Engineering at ICSE 2001},
	year = {2001},
	abstract = {As open source software engineering becomes more prevalent, employing sound software engineering practices and the tools used to implement these practices becomes more important. This paper examines the current status of free software engineering tools. For each set of tools, we determined the important attributes that would best assist a developer in each stage of the waterfall model. We rated each tool based on predetermined attributes. We used the creation of a graphical user interface based email client in Java to assist in evaluating each tool. Our findings show that there is still a need for free tools to extract UML diagrams, test graphical user interfaces, make configuring Emacs easier, and profile Java applications. In other areas there are free tools that provide satisfactory functionality such as Concurrent Versions System (CVS), GVim, JUnit, JRefactory, GNU Make, Jakarta Ant, Javadoc, and Doc++.},
	keywords = {applications, cvs, Doc++, GNU Make, GVim, Jakarta Ant, java, Javadoc, jrefactory, junit, tools},
	attachments = {https://flosshub.org/sites/flosshub.org/files/bittman.pdf},
	author = {Bittman, M. and Roos, R. and Kapfhammer, G.M.}
}
@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 {98,
	title = {Striking a balance between trust anti control in a virtual organization: a content analysis of open source software case studies},
	journal = {Information Systems Journal},
	volume = {11},
	number = {4},
	year = {2001},
	note = {"I employ secondary analysis of published case studies of OSS projects. I used several search methods to identify such case studies about OSS pro- jects. First, I searched the electronic archives of both ACM and IEEE, using terms such as {\textquoteleft}open source.{\textquoteright} "
"Secondly, I searched on Bell \& Howell/Proquest{\textquoteright}s ABI/Inform, a database of acade- mic and trade publications on business and management (including technology management). Thirdly, I reviewed the {\textquoteleft}position papers{\textquoteright} of the various authors who attended the 1st Work- shop on Open-Source Software Engineering (Feller et al., 2001) for relevant case studies. Fourthly, I searched on Harvard Publishing{\textquoteright}s websites, which contain case studies published"
"Finally, as I located case studies or other publi- cations about OSS projects, I followed references from them to identify other case studies. Although I found literally hundreds of publications about OSS development, there was a much smaller number of case studies"},
	pages = {277-304},
	abstract = {Many organization theorists have predicted the emergence of the networked or virtual firm as a model for the design of future organizations. Researchers have also emphasized the importance of trust as a necessary condition for ensuring the success of virtual organizations. This paper examines the open source software (OSS) {\textquoteright}movement{\textquoteright} as an example of a virtual organization and proposes a model that runs contrary to the belief that trust is critical for virtual organizations. Instead, I argue that various control mechanisms can ensure the effective performance of autonomous agents who participate in virtual organizations. Borrowing from the theory of the {\textquoteright}McDonaldization{\textquoteright} of society, I argue that, given a set of practices to ensure the control, efficiency, predictability and calculability of processes and outcomes in virtual organizations, effective performance may occur in the absence of trust. As support for my argument, I employ content analysis to examine a set of published case studies of OSS projects. My results show that, although that trust is rarely mentioned, ensuring control is an important criterion for effective performance within OSS projects. The case studies feature few references to other dimensions of {\textquoteright}McDonaldization{\textquoteright} (efficiency, predictability and calculability), however, and I conclude that the OSS movement relies on many other forms of social control and self-control, which are often unacknowledged in OSS projects. Through these implicit forms of control, OSS projects are able to secure the cooperation of the autonomous agents that participate in project teams. I conclude by extrapolating from these case studies to other virtual organizations.},
	keywords = {apache, case studies, Control, fetchmail, jun, linux, linux kernel, McDonaldization, mozilla, networked organization, perl, rationalization, trust, virtual organization},
	author = {Gallivan, M. J.}
}
@article {flosswp26,
	title = {A Case Study of Open Source Software Development: The Apache Server},
	journal = {Proceedings of the International Conference on Software Engineering (ICSE 2000)},
	year = {2000},
	note = {We used the following archival sources of data:
Developer email list (EMAIL).
Concurrent Version Control archive (CVS).
Problem reporting database (BUGDB).},
	month = {June},
	abstract = {According to its proponents, open source style software development has the capacity to compete successfully, and perhaps in many cases displace, traditional commercial development methods. We examine the development process of a major open source application, the Apache web server. By using email archives of source code change history and problem reports we quantify aspects of developer participation, core team size, code ownership, productivity, defect density, and problem resolution interval for this OSS project. This analysis reveals a unique process, which performs well on important measures.},
	keywords = {apache, bug fix revisions, bugs, core, cvs, defect density, developers, email archives, participation, productivity, revision control, revision history, roles, scm, source code, team size},
	attachments = {https://flosshub.org/sites/flosshub.org/files/mockusapache.pdf},
	author = {Audris Mockus and Roy Fielding and Herbsleb, James}
}
