@proceedings {1915,
	title = {Classifying code comments in Java open-source software systems},
	year = {2017},
	note = {"we conducted an in-depth analysis of the
comments in the source code files of six major OSS systems
in Java"},
	month = {05/2017},
	pages = {227-237},
	abstract = {Code comments are a key software component
containing information about the underlying implementation.
Several studies have shown that code comments enhance the
readability of the code. Nevertheless, not all the comments have
the same goal and target audience. In this paper, we investigate
how six diverse Java OSS projects use code comments, with the
aim of understanding their purpose. Through our analysis, we
produce a taxonomy of source code comments; subsequently, we
investigate how often each category occur by manually classifying
more than 2,000 code comments from the aforementioned
projects. In addition, we conduct an initial evaluation on how
to automatically classify code comments at line level into our
taxonomy using machine learning; initial results are promising
and suggest that an accurate classification is within reach.},
	keywords = {java, Survey},
	author = {Luca Pascarella and Bacchelli, Alberto}
}
@booklet {1709,
	title = {Understanding and Supporting the Choice of an Appropriate Task to Start With In Open Source Software Communities },
	howpublished = {Hawaii International Conference on System Sciences 48},
	year = {2015},
	pages = {5299-5308},
	publisher = {IEEE},
	abstract = {Open Source Software (OSS) projects leverage the
contribution of outsiders. In fact, the sustainability of
many projects relies on retaining some of these
newcomers. Usually these communities do not
coordinate the work of the newcomers, who go to the
issue trackers and self-select a task to start with. We
found that {\textquotedblleft}finding a way to start{\textquotedblright} was reported as an
important issue by practitioners. To further investigate
this specific barrier, we conducted a qualitative
analysis with data obtained from semi-structured
interviews with 36 subjects from 14 different projects,
including newcomers and experienced members. We
used procedures of Grounded Theory {\textendash} open and axial
coding {\textendash} to analyze the data. We found that newcomers
are not confident enough to choose their initial task
and they need information about the tasks or direction
from the community to support choosing a task more
suitable for them. We also present a set of strategies
identified in the literature, interviews, and state-of-the practice
that can provide newcomers with such
information, enabling them to be more confident when
choosing their first tasks and collaborate with the
community. },
	keywords = {coordination, joining process, new developer, newcomers, onboarding, open source software, task selection},
	attachments = {https://flosshub.org/sites/flosshub.org/files/HICSS-48_present.pdf},
	author = {Steinmacher, Igor and Conte, Tayana and Gerosa, MarcoAur{\'e}lio}
}
@proceedings {1752,
	title = {Why Power Laws? An Explanation from Fine-Grained Code Changes},
	year = {2015},
	note = {"The data used in this section come from four open source Java projects. We used CVSANALY to collect data from their Git repositories."},
	abstract = {Throughout the years, empirical studies have found
power law distributions in various measures across many software
systems. However, surprisingly little is known about how
they are produced. What causes these power law distributions?
We offer an explanation from the perspective of fine-grained
code changes. A model based on preferential attachment and selforganized
criticality is proposed to simulate software evolution.
The experiment shows that the simulation is able to render power
law distributions out of fine-grained code changes, suggesting
preferential attachment and self-organized criticality are the
underlying mechanism causing the power law distributions in
software systems.},
	keywords = {Apache Maven, cvsanaly, eclipse, git, Google Guice, java, jedit, open source},
	url = {https://users.soe.ucsc.edu/~linzhp/msr2015.pdf},
	attachments = {https://flosshub.org/sites/flosshub.org/files/msr2015.pdf},
	author = {Zhongpeng Lin and Jim Whitehead}
}
@proceedings {1501,
	title = {The Impact of Tangled Code Changes},
	year = {2013},
	month = {05/2013},
	abstract = {When interacting with version control systems, developers often commit unrelated or loosely related code changes
in a single transaction. When analyzing the version history, such
tangled changes will make all changes to all modules appear
related, possibly compromising the resulting analyses through
noise and bias. In an investigation of five open-source JAVA
projects, we found up to 15\% of all bug fixes to consist of multiple
tangled changes. Using a multi-predictor approach to untangle
changes, we show that on average at least 16.6\% of all source
files are incorrectly associated with bug reports. We recommend
better change organization to limit the impact of tangled changes.},
	keywords = {bias, data quality, history, java, mining software repositories, noise, tangled code changes, version control},
	url = {http://www.kim-herzig.de/wp-content/uploads/2013/03/msr2013-untangling.pdf},
	attachments = {https://flosshub.org/sites/flosshub.org/files/msr2013-untangling.pdf},
	author = {Kim Herzig and Zeller, Andreas}
}
@proceedings {1444,
	title = {Gender Differences in Early Free and Open Source Software Joining Process},
	volume = {378},
	year = {2012},
	note = {"We examined subscriber logs and data for six FOSS projects..."
"We examined the differences between posters and non-posters to determine the attrition rate..."
"Using data from the US Census, we matched names to lists of the most common female and male names. We identified 666 users using this process."},
	month = {09/2012},
	pages = {78-93},
	publisher = {IFIP AICT, Springer},
	address = {Eighth International Conference on Open Source Systems (OSS 2012)},
	abstract = {With the growth of free and open source software (FOSS) and the adoption of FOSS solutions in business and everyday life, it is important that projects serve their growingly diverse user base. The sustainability of FOSS projects relies on a constant influx of new contributors. Several large demo- graphic surveys found that FOSS communities are very homogenous, dominated by young men, similar to the bias existing in the rest of the IT workforce. Building on previous research, we examine mailing list subscriptions and posting statistics of female FOSS participants. New participants often experience their first interaction on a FOSS project{\textquoteright}s mailing list. We explored six FOSS projects {\textendash} Buildroot, Busybox, Jaws, Parrot, uClibc, and Yum. We found a declining rate of female participation from the 8.27\% of subscribers, to 6.63\% of posters, and finally the often reported code contributor rate of 1.5\%. We found a disproportionate attrition rate among women along every step of the FOSS joining process.},
	keywords = {buildroot, busybox, diversity, email, jaws, joining process, mailing lists, parrot, uClibc, Yum},
	author = {Kuechler, Victor and Gilbertson, Claire and Jensen, Carlos}
}
@article {1381,
	title = {Adopting Free/Libre/Open Source Software Practices, Techniques and Methods for Industrial Use},
	journal = {Journal of the Association for Information Systems},
	volume = {12},
	number = {1},
	year = {2011},
	abstract = {Today{\textquoteright}s software companies face the challenges of highly distributed development projects and constantly changing requirements. This paper proposes the adoption of relevant Free/Libre/Open Source Software (FLOSS) practices in order to improve software development projects in industry. Many FLOSS projects have proven to be very successful, producing high quality products with steady and frequent releases. This study aims to identify FLOSS practices that can be adapted for the corporate environment. To achieve this goal, a framework to compare FLOSS and industrial development methodologies was created. Three successful FLOSS projects were selected as study targets (the Linux Kernel, the FreeBSD operating system, and the JBoss application server), as well as two projects from Ericsson, a large telecommunications company. Based on an analysis of these projects, FLOSS best practices were tailored to fit industrial development environments. The final results consisted of a set of key adoption opportunities that aimed to improve software quality and overall development productivity by importing best practices from the FLOSS environment. The adoption opportunities were then validated at three large corporations.},
	keywords = {freebsd, jboss, linux, linux kernel},
	url = {http://aisel.aisnet.org/jais/vol12/iss1/1},
	author = {Torkar, Richard and Minoves, Pau and Garrig{\'o}s, Janina}
}
@proceedings {1288,
	title = {An Analysis of Author Contribution Patterns in Eclipse Foundation Project Source Code},
	year = {2011},
	note = {"We conducted an observational study on existing Eclipse projects by extracting author attribution data for Java source code files from git repositories."

"Specifically, we consider entropy of source code by counting the number of lines attributed to each author."},
	month = {10/2011},
	pages = {269-281},
	publisher = {Springer},
	abstract = {Collaborative development is a key tenet of open source software, but if not properly understood and managed, it can become a liability. We examine author contribution data for the newest revision of 251,633 Java source files in 592 Eclipse projects. We use this observational data to analyze collaboration patterns within files, and to explore relationships between file size, author count, and code authorship. We calculate author entropy to characterize the contributions of multiple authors to a given file, with an eye toward understanding the degree of collaboration and the most common interaction patterns.},
	keywords = {COLLABORATION, contribution, eclipse, entropy, java},
	author = {Taylor, Quinn C. and Krein, Jonathan L. and MacLean, Alexander C. and Knutson, Charles D.}
}
@article {1806,
	title = {An empirical study of software architectures{\textquoteright} effect on product quality},
	journal = {Journal of Systems and Software},
	volume = {84},
	year = {2011},
	note = {"We first collected meta-data on the 21,094 most highly ranked Java projects on 2009-03-17 from SourceForge for which it was possible to get such data. Here {\textquotedblleft}Java projects{\textquotedblright} were defined as projects belonging to {\textquotedblleft}trove{\textquotedblright} 198 at SourceForge and {\textquotedblleft}rank{\textquotedblright} was the SourceForge ranking of projects. The data consisted of characteristics such as number of bugs, time of latest file upload, number of developers, number of open bugs, and SourceForge {\textquotedblleft}rank{\textquotedblright}." They did not use FLOSSmole, "A more complete analysis of the project status, could be performed by mining the FLOSSMole database (Howison et al., 2006)."},
	month = {7/2011},
	pages = {1233 - 1243},
	abstract = {Software architecture is concerned with the structure of software systems and is generally agreed to influence software quality. Even so, little empirical research has been performed on the relationship between software architecture and software quality. Basedon 1,141 open source Java projects, we calculate three software architecture metrics (measuring classes per package, normalizeddistance, and a new metric introduced by us concerning the excess of coupling degree) and analyze to which extent these metricsare related to product metrics (defect ratio, download rate, methods per class, and method complexity). We conclude that there area number of significant relationships between product metrics and architecture metrics.  In particular, the number of open defectsdepends significantly on all our architecture measures.},
	keywords = {flossmole cited, java},
	issn = {01641212},
	doi = {10.1016/j.jss.2011.02.037},
	url = {http://www.sciencedirect.com/science/article/pii/S0164121211000574},
	author = {Hansen, Klaus Marius and Jonasson, Kristjan and Neukirchen, Helmut}
}
@proceedings {1282,
	title = {A Historical Account of the Value of Free and Open Source Software: From Software Commune to Commercial Commons},
	year = {2011},
	note = {"In order to understand how perceptions of FOSS software have developed over time, we have traced justifying arrangements that historically have been used to define the value of FOSS. This has been done by going through canonical texts and previous research [3]; i.e. we look at research and publications considered to have had a major impact on the perception of FOSS...."

Software Commune, software bazaar, public commons},
	month = {10/2011},
	pages = {196-207},
	publisher = {Springer},
	abstract = {Free and open source software has transformed from what has been characterized as a resistance movement against proprietary software to become a commercially viable form of software development, integrated in various forms with proprietary software business. In this paper we explain this development as a dependence on historical formations, shaped by different ways of justifying the use of open source during different periods of time. These formations are described as arrangements of different justificatory logics within a certain time frame or a certain group of actors motivating the use of free and open source software by referring to different potentialities. The justificatory arrangements change over time, and tracing these changes makes it easier to understand how the cultural, economic and social practices of open source movements are currently being absorbed and adopted in a commercial context.},
	keywords = {Free and Open Source Software, Historical approach, Justification}
}
@proceedings {1270,
	title = {Impact of Stakeholder Type and Collaboration on Issue Resolution Time in OSS Projects},
	year = {2011},
	note = {"First, we characterize the difference in the average amount of resolved issues and issue resolution time between a volunteer assignee and a firm-paid assignee....Second, we investigate collaboration among stakeholders in OSS projects by using Social network metrics and analysis. Last, we explore the impact of the collaboration measures on issue resolution time."

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

"All software issues were collected from JIRA repositories...Issue resolution time was computed by using the created time field and the issue resolved time field."},
	month = {10/2011},
	pages = {1-16},
	publisher = {Springer},
	abstract = {Initialized by a collective contribution of volunteer developers, Open source software (OSS) attracts an increasing involvement of commercial firms. Many OSS projects are composed of a mix group of firm-paid and volunteer developers, with different motivations, collaboration practices and working styles. As OSS development consists of collaborative works in nature, it is important to know whether these differences have an impact on collaboration between difference types of stakeholders, which lead to an influence in the project outcomes. In this paper, we empirically investigate the firm-paid participation in resolving OSS evolution issues, the stakeholder collaboration and its impact on OSS issue resolution time. The results suggest that though a firm-paid assigned developer resolves much more issues than a volunteer developer does, there is no difference in issue resolution time between them. Besides, the more important factor that influences the issue resolution time comes from the collaboration among stakeholders rather than from individual characteristics.},
	keywords = {COLLABORATION, companies, coordination, defects, feature requests, geronimo, jira, qpid, qt, social network analysis, volunteer},
	author = {Duc, Ach Nguyen and Cruzes, Daniela S. and Ayala, Claudia and Conradi, Reidar}
}
@conference {1306,
	title = {Java generics adoption},
	booktitle = {Proceedings of the 8th working conference on Mining software repositories - MSR {\textquoteright}11},
	year = {2011},
	note = {"we automatically analyzed 20 open source software projects. We analyzed the top {\textquotedblleft}most used{\textquotedblright} projects according to ohloh.net, including only projects with significant amounts of Java code"

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

"In mining the full version histories of these 20 projects, we analyzed the full content of each version of each Java source file, a total of 548,982,841 lines."},
	month = {05/2011},
	pages = {3-12},
	publisher = {ACM Press},
	organization = {ACM Press},
	address = {New York, New York, USA},
	abstract = {Support for generic programming was added to the Java language in 2004, representing perhaps the most significant change to one of the most widely used programming languages today. Researchers and language designers anticipated this addition would relieve many long-standing problems plaguing developers, but surprisingly, no one has yet measured whether generics actually provide such relief. In this paper, we report on the first empirical investigation into how Java generics have been integrated into open source software by automatically mining the history of 20 popular open source Java programs, traversing more than 500 million lines of code in the process. We evaluate five hypotheses, each based on assertions made by prior researchers, about how Java developers use generics. For example, our results suggest that generics do not significantly reduce the number of type casts and that generics are usually adopted by a single champion in a project, rather than all committers.},
	keywords = {commits, generics, java, source code, version history},
	isbn = {9781450305747},
	doi = {10.1145/1985441.1985446},
	author = {Christian Bird and Murphy-Hill, Emerson and Parnin, Chris}
}
@conference {963,
	title = {Automated dependency resolution for open source software},
	booktitle = {2010 7th IEEE Working Conference on Mining Software Repositories (MSR 2010)2010 7th IEEE Working Conference on Mining Software Repositories (MSR 2010)},
	year = {2010},
	pages = {130 - 140},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Cape Town, South Africa},
	abstract = {Opportunities for software reuse are plentiful, thanks in large part to the widespread adoption of open source processes and the availability of search engines for locating relevant artifacts. One challenge presented by open source software reuse is simply getting a newly downloaded artifact to build/run in the first place. The artifact itself likely reuses other artifacts, and so depends on their being located to function properly. While merely tedious in the individual case, this can cause serious difficulties for those seeking to study open source software. It is simply not feasible to manually resolve dependencies for thousands of projects, and many forms of analysis require declarative completeness. In this paper we present a method for automatically resolving dependencies for open source software. It works by cross-referencing a project{\textquoteright}s missing type information with a repository of candidate artifacts. We have implemented this method on top of the Sourcerer, an infrastructure for the large-scale indexing and analysis of open source code. The performance of our resolution algorithm was evaluated in two parts. First, for a small number of popular open source projects, we manually examined the artifacts suggested by our system to determine if they were appropriate. Second, we applied the algorithm to the 13,241 projects in the Sourcerer managed repository to evaluate the rate of resolution success. The results demonstrate the feasibility of this approach, as the algorithm located all of the required artifacts needed by 3,904 additional projects, increasing the percentage of declaratively complete projects in Sourcerer from 39\% to 69\%.},
	keywords = {dependencies, java, source code, sourcerer},
	isbn = {978-1-4244-6802-7},
	doi = {10.1109/MSR.2010.5463346},
	author = {Ossher, Joel and Bajracharya, Sushil and Lopes, Cristina}
}
@conference {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 {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 {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 {943,
	title = {Automatic labeling of software components and their evolution using log-likelihood ratio of word frequencies in source code},
	booktitle = {2009 6th IEEE International Working Conference on Mining Software Repositories (MSR)2009 6th IEEE International Working Conference on Mining Software Repositories},
	year = {2009},
	pages = {175 - 178},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Vancouver, BC, Canada},
	abstract = {As more and more open-source software components become available on the Internet we need automatic ways to label and compare them. For example, a developer who searches for reusable software must be able to quickly gain an understanding of retrieved components. This understanding cannot be gained at the level of source code due to the semantic gap between source code and the domain model. In this paper we present a lexical approach that uses the log-likelihood ratios of word frequencies to automatically provide labels for software components. We present a prototype implementation of our labeling/comparison algorithm and provide examples of its application. In particular, we apply the approach to detect trends in the evolution of a software system.},
	keywords = {frequency, hapax, information retrieval, java, junit, keywords, labeling, source code},
	isbn = {978-1-4244-3493-0},
	doi = {10.1109/MSR.2009.5069499},
	attachments = {https://flosshub.org/sites/flosshub.org/files/175AutomaticLabeling.pdf},
	author = {Kuhn, Adrian}
}
@conference {928,
	title = {Mining source code to automatically split identifiers for software analysis},
	booktitle = {2009 6th IEEE International Working Conference on Mining Software Repositories (MSR)2009 6th IEEE International Working Conference on Mining Software Repositories},
	year = {2009},
	pages = {71 - 80},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Vancouver, BC, Canada},
	abstract = {Automated software engineering tools (e.g., program search, concern location, code reuse, quality assessment, etc.) increasingly rely on natural language information from comments and identifiers in code. The first step in analyzing words from identifiers requires splitting identifiers into their constituent words. Unlike natural languages, where space and punctuation are used to delineate words, identifiers cannot contain spaces. One common way to split identifiers is to follow programming language naming conventions. For example, Java programmers often use camel case, where words are delineated by uppercase letters or non-alphabetic characters. However, programmers also create identifiers by concatenating sequences of words together with no discernible delineation, which poses challenges to automatic identifier splitting. In this paper, we present an algorithm to automatically split identifiers into sequences of words by mining word frequencies in source code. With these word frequencies, our identifier splitter uses a scoring technique to automatically select the most appropriate partitioning for an identifier. In an evaluation of over 8000 identifiers from open source Java programs, our Samurai approach outperforms the existing state of the art techniques.},
	keywords = {java, samurai, sourceforge},
	isbn = {978-1-4244-3493-0},
	doi = {10.1109/MSR.2009.5069482},
	attachments = {https://flosshub.org/sites/flosshub.org/files/71EnslenandHillandPollockandVijayShanker.pdf},
	author = {Enslen, Eric and Hill, Emily and Pollock, Lori and Vijay-Shanker, K.}
}
@conference {1066,
	title = {SourcererDB: An aggregated repository of statically analyzed and cross-linked open source Java projects},
	booktitle = {2009 6th IEEE International Working Conference on Mining Software Repositories (MSR)},
	year = {2009},
	pages = {183 - 186},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Vancouver, BC, Canada},
	abstract = {The open source movement has made vast quantities of source code available online for free, providing an extremely large dataset for empirical study and potential re-use. A major difficulty in exploiting this potential fully is that the data are currently scattered between competing source code repositories, none of which are structured for empirical analysis and cross-project comparison. As a result, software researchers and developers are left to compile their own datasets, resulting in duplicated effort and limited results. To address this challenge, we built SourcererDB, an aggregated repository of statically analyzed and cross-linked open source Java projects. SourcererDB contains local snapshots of 2,852 Java projects taken from Sourceforge, Apache and Java.net. These projects are statically analyzed to extract rich structural information, which is then stored in a relational database. References to entities in the 16,058 external jars are resolved and grouped, allowing for cross-project usage information to be accessed easily. This paper describes: (a) the mechanism for resolving and grouping these cross-project references, (b) the structure of and the metamodel for the SourcererDB repository, and (d) end-user dataset access mechanisms. Our goal in building SourcererDB is to provide a rich dataset of source code to facilitate the sharing of extracted data and to encourage reuse and repeatability of experiments.},
	keywords = {apache, java, java.net, source code, sourceforge, sourcerer},
	isbn = {978-1-4244-3493-0},
	doi = {10.1109/MSR.2009.5069501},
	author = {Ossher, Joel and Bajracharya, Sushil and Linstead, Erik and Baldi, Pierre and Lopes, Cristina}
}
@conference {945,
	title = {SourcererDB: An aggregated repository of statically analyzed and cross-linked open source Java projects},
	booktitle = {2009 6th IEEE International Working Conference on Mining Software Repositories (MSR)2009 6th IEEE International Working Conference on Mining Software Repositories},
	year = {2009},
	pages = {183 - 186},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Vancouver, BC, Canada},
	abstract = {The open source movement has made vast quantities of source code available online for free, providing an extremely large dataset for empirical study and potential resuse. A major difficulty in exploiting this potential fully is that the data are currently scattered between competing source code repositories, none of which are structured for empirical analysis and cross-project comparison. As a result, software researchers and developers are left to compile their own datasets, resulting in duplicated effort and limited results. To address this challenge, we built SourcererDB, an aggregated repository of statically analyzed and cross-linked open source Java projects. SourcererDB contains local snapshots of 2,852 Java projects taken from Sourceforge, Apache and Java.net. These projects are statically analyzed to extract rich structural information, which is then stored in a relational database. References to entities in the 16,058 external jars are resolved and grouped, allowing for cross-project usage information to be accessed easily. This paper describes: (a) the mechanism for resolving and grouping these cross-project references, (b) the structure of and the metamodel for the SourcererDB repository, and (d) end-user dataset access mechanisms. Our goal in building SourcererDB is to provide a rich dataset of source code to facilitate the sharing of extracted data and to encourage reuse and repeatability of experiments.},
	keywords = {apache, integration, java, java.net, project, repository, sourceforge, SourcererDB},
	isbn = {978-1-4244-3493-0},
	doi = {10.1109/MSR.2009.5069501},
	author = {Ossher, Joel and Bajracharya, Sushil and Linstead, Erik and Baldi, Pierre and Lopes, Cristina}
}
@conference {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 {Thummalapenta:2008:SDF:1370750.1370775,
	title = {SpotWeb: detecting framework hotspots via mining open source repositories on the web},
	booktitle = {Proceedings of the 2008 international working conference on Mining software repositories},
	series = {MSR {\textquoteright}08},
	year = {2008},
	month = {05/2008},
	pages = {109{\textendash}112},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {The essentials of modern software development (such as low cost and high efficiency) demand software developers to make intensive reuse of existing open source frameworks or libraries (generally referred as frameworks) available on the web. However, developers often face challenges in reusing these frameworks due to several factors such as the complexity and lack of proper documentation. In this paper, we propose a code-search-engine-based approach that tries to detect hotspots in a given framework by mining code examples gathered from open source repositories available on the web; these hotspots are the APIs that are frequently reused.

Hotspots can serve as starting points for developers in understanding and reusing the given framework. We developed a tool, called SpotWeb, for frameworks or libraries written in Java and conducted two case studies with two open source frameworks JUnit and Log4j. We also show that the detected hotspots of Log4j and JUnit are consistent with their respective documentations.},
	keywords = {code reuse, code search engine, frameworks, hotspots, junit, log4j, repositories},
	isbn = {978-1-60558-024-1},
	doi = {http://doi.acm.org/10.1145/1370750.1370775},
	url = {http://doi.acm.org/10.1145/1370750.1370775},
	attachments = {https://flosshub.org/sites/flosshub.org/files/p109-thummalapenta.pdf},
	author = {Thummalapenta, Suresh and Xie, Tao}
}
@conference {991,
	title = {How Long Will It Take to Fix This Bug?},
	booktitle = {Fourth International Workshop on Mining Software Repositories (MSR{\textquoteright}07:ICSE Workshops 2007)},
	year = {2007},
	pages = {1},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Minneapolis, MN, USA},
	abstract = {Predicting the time and effort for a software problem has long been a difficult task. We present an approach that automatically predicts the fixing effort, i.e., the person-hours spent on fixing an issue. Our technique leverages existing issue tracking systems: given a new issue report, we use the Lucene framework to search for similar, earlier reports and use their average time as a prediction. Our approach thus allows for early effort estimation, helping in assigning issues and scheduling stable releases. We evaluated our approach using effort data from the JBoss project. Given a sufficient number of issues reports, our automatic predictions are close to the actual effort; for issues that are bugs, we are off by only one hour, beating naive predictions by a factor of four.},
	keywords = {bug fixing, bug reports, effort estimation, jboss, lucene, prediction, time},
	isbn = {0-7695-2950-X},
	doi = {10.1109/MSR.2007.13},
	attachments = {https://flosshub.org/sites/flosshub.org/files/28300001.pdf},
	author = {Weiss, Cathrin and Premraj, Rahul and Zimmermann, Thomas and Zeller, Andreas}
}
@conference {999,
	title = {Mining Software Repositories with iSPAROL and a Software Evolution Ontology},
	booktitle = {Fourth International Workshop on Mining Software RepositoriesFourth International Workshop on Mining Software Repositories (MSR{\textquoteright}07:ICSE Workshops 2007)},
	year = {2007},
	pages = {10 - 10},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Minneapolis, MN, USA},
	abstract = {One of the most important decisions researchers face when analyzing the evolution of software systems is the choice of a proper data analysis/exchange format. Most existing formats have to be processed with special programs written specifically for that purpose and are not easily extendible. Most scientists, therefore, use their own database(s) requiring each of them to repeat the work of writing the import/export programs to their format.

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

The paper also shows iSPARQL -- our SPARQL-based Semantic Web query engine containing similarity joins. Together with EvoOnt, iSPARQL can accomplish a sizable number of tasks sought in software repository mining projects, such as an assessment of the amount of change between versions or the detection of bad code smells. To illustrate the usefulness of EvoOnt (and iSPARQL), we perform a series of experiments with a real-world Java project. These show that a number of software analyses can be reduced to simple iSPARQL queries on an EvoOnt dataset.},
	keywords = {database, eclipse, evoont, java, owl, semantic, sparql},
	isbn = {0-7695-2950-X},
	doi = {10.1109/MSR.2007.21},
	attachments = {https://flosshub.org/sites/flosshub.org/files/28300010.pdf},
	author = {Kiefer, Christoph and Bernstein, Abraham and Tappolet, Jonas}
}
@conference {1000,
	title = {Mining Workspace Updates in CVS},
	booktitle = {Fourth International Workshop on Mining Software Repositories (MSR{\textquoteright}07:ICSE Workshops 2007)},
	year = {2007},
	pages = {11 - 11},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Minneapolis, MN, USA},
	abstract = {The version control archive CVS records not only all changes in a project but also activity data such as when developers create or update their workspaces. Furthermore, CVS records when it has to integrate changes because of parallel development. In this paper, we analyze the CVS activity data of four large open-source projects GCC, JBOSS, JEDIT, and PYTHON to investigate parallel development: What is the degree of parallel development? How frequently do conflicts occur during updates and how are they resolved? How do we identify changes that contain integrations?},
	keywords = {change management, cvs, developers, gcc, jboss, jedit, python, workspaces},
	isbn = {0-7695-2950-X},
	doi = {10.1109/MSR.2007.22},
	attachments = {https://flosshub.org/sites/flosshub.org/files/28300011.pdf},
	author = {Zimmermann, Thomas}
}
@conference {995,
	title = {Open Borders? Immigration in Open Source Projects},
	booktitle = {Fourth International Workshop on Mining Software RepositoriesFourth International Workshop on Mining Software Repositories (MSR{\textquoteright}07:ICSE Workshops 2007)},
	year = {2007},
	pages = {6 - 6},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Minneapolis, MN, USA},
	abstract = {Open source software is built by teams of volunteers. Each project has a core team of developers, who have the authority to commit changes to the repository; this team is the elite, committed foundation of the project, selected through a meritocratic process from a larger number of people who participate on the mailing list. Most projects carefully regulate admission of outsiders to full developer privileges; some projects even have formal descriptions of this process. Understanding the factors that influence the "who, how and when" of this process is critical, both for the sustainability of FLOSS projects, and for outside stakeholders who want to gain entry and succeed. In this paper we mount a quantitative case study of the process by which people join FLOSS projects, using data mined from the Apache web server, Postgres, and Python. We develop a theory of open source project joining, and evaluate this theory based on our data.},
	keywords = {apache, core, joining, postgresql, python, team},
	isbn = {0-7695-2950-X},
	doi = {10.1109/MSR.2007.23},
	attachments = {https://flosshub.org/sites/flosshub.org/files/28300006.pdf},
	author = {Christian Bird and Gourley, Alex and Devanbu, Prem and Swaminathan, Anand and Hsu, Greta}
}
@conference {1214,
	title = {A Preliminary Analysis of Publicly Available FLOSS Measurements: Towards Discovering Maintainability Trends},
	booktitle = {2nd Workshop on Public Data about Software Development (WoPDaSD 2007)},
	year = {2007},
	note = {used SourceKibitzer data downloaded from FLOSSmole},
	month = {2007},
	abstract = {The spread of free/libre/open source software (FLOSS) and the openness of its development model offer researchers a valuable source of information regarding software data. The creation of large portals, which host a vast amount of FLOSS projects make it easy to create large datasets with valuable information regarding the FLOSS development process. In addition initiatives such as FLOSSMole provide researchers with a single point and continuing access to those data. Up to now the majority of datasets from FLOSSMole offered data regarding the development process and not the code itself. From February 2007 FLOSSMole offers data donated 
by SourceKibitzer, which contain source code metrics for FLOSS projects written in Java. In this paper we provide 
a premilinary analysis on those data using machine learning techniques, such as classification rules and decision trees. Using the first available data from February 2007, we tried to build rules that can be used in order to estimate the future values of metrics offered for March. Here we present some preliminary results that are encouraging and deserve to be further analyzed in future releases of SourceKibitzer datasets. },
	keywords = {decision tree, flossmole, java, machine learning, metrics, sourcekibitzer},
	attachments = {https://flosshub.org/sites/flosshub.org/files/Samolades2007.pdf},
	author = {Samoladas, Ioannis and Bibi, Stamatia and Ioannis Stamelos and Sowe, Sulayman K. and Deligiannis, Ignatios}
}
@conference {1012,
	title = {Prioritizing Warning Categories by Analyzing Software History},
	booktitle = {Fourth International Workshop on Mining Software Repositories (MSR{\textquoteright}07:ICSE Workshops 2007)},
	year = {2007},
	pages = {27 - 27},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Minneapolis, MN, USA},
	abstract = {Automatic bug finding tools tend to have high false positive rates: most warnings do not indicate real bugs. Usually bug finding tools prioritize each warning category. For example, the priority of "overflow" is 1 and the priority of "jumbled incremental" is 3, but the tools{\textquoteright} prioritization is not very effective.

In this paper, we prioritize warning categories by analyzing the software change history. The underlying intuition is that if warnings from a category are resolved quickly by developers, the warnings in the category are important. Experiments with three bug finding tools (FindBugs, JLint, and PMD) and two open source projects (Columba and jEdit) indicate that different warning categories have very different lifetimes. Based on that observation, we propose a preliminary algorithm for warning category prioritizing.},
	keywords = {bug fixing, change history, columba, findbugs, jedit, jlint, kenyon, pmd, warning},
	isbn = {0-7695-2950-X},
	doi = {10.1109/MSR.2007.26},
	attachments = {https://flosshub.org/sites/flosshub.org/files/28300027.pdf},
	author = {Kim, Sunghun and Ernst, Michael D.}
}
@conference {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 {998,
	title = {Visual Data Mining in Software Archives to Detect How Developers Work Together},
	booktitle = {Fourth International Workshop on Mining Software RepositoriesFourth International Workshop on Mining Software Repositories (MSR{\textquoteright}07:ICSE Workshops 2007)},
	year = {2007},
	pages = {9 - 9},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Minneapolis, MN, USA},
	abstract = {Analyzing the check-in information of open source software projects which use a version control system such as CVS or SUBVERSION can yield interesting and important insights into the programming behavior of developers. As in every major project tasks are assigned to many developers, the development must be coordinated between these programmers.

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

To demonstrate the usefulness of these visualization techniques we performed case studies on two open source projects. In these studies interesting patterns of developers? behavior, e.g. the specialization on a certain module can be observed. Moreover, modules that have been changed by many developers can be identified as well as such ones that have been altered by only one programmer.},
	keywords = {change, coordination, cvs, developers, junit, modules, scm, source code, svn, teams, tomcat, visualization},
	isbn = {0-7695-2950-X},
	doi = {10.1109/MSR.2007.34},
	attachments = {https://flosshub.org/sites/flosshub.org/files/28300009.pdf},
	author = {Weissgerber, Peter and Pohl, Mathias and Burch, Michael}
}
@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.}
}
@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 {Sager:2006:DSJ:1137983.1138000,
	title = {Detecting similar Java classes using tree algorithms},
	booktitle = {Proceedings of the 2006 international workshop on Mining software repositories},
	series = {MSR {\textquoteright}06},
	year = {2006},
	pages = {65{\textendash}71},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {Similarity analysis of source code is helpful during development to provide, for instance, better support for code reuse. Consider a development environment that analyzes code while typing and that suggests similar code examples or existing implementations from a source code repository. Mining software repositories by means of similarity measures enables and enforces reusing existing code and reduces the developing effort needed by creating a shared knowledge base of code fragments. In information retrieval similarity measures are often used to find documents similar to a given query document. This paper extends this idea to source code repositories. It introduces our approach to detect similar Java classes in software projects using tree similarity algorithms. We show how our approach allows to find similar Java classes based on an evaluation of three tree-based similarity measures in the context of five user-defined test cases as well as a preliminary software evolution analysis of a medium-sized Java project. Initial results of our technique indicate that it (1) is indeed useful to identify similar Java classes, (2)successfully identifies the ex ante and ex post versions of refactored classes, and (3) provides some interesting insights into within-version and between-version dependencies of classes within a Java project.},
	keywords = {change analysis, clones, coogle, eclipse, famix, java, similarity, software evolution, software repositories, source code, tree similarity measures},
	isbn = {1-59593-397-2},
	doi = {http://doi.acm.org/10.1145/1137983.1138000},
	url = {http://doi.acm.org/10.1145/1137983.1138000},
	attachments = {https://flosshub.org/sites/flosshub.org/files/65Detecting.pdf},
	author = {Sager, Tobias and Bernstein, Abraham and Pinzger, Martin and Kiefer, Christoph}
}
@conference {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}
}
@article {2006,
	title = {Opportunities and Challenges Applying Functional Data Analysis to the Study of Open Source Software Evolution},
	journal = {Statistical Science},
	volume = {21},
	number = {2},
	year = {2006},
	note = {"As part of a larger project, data were collected on 105 OSS	projects hosted online at Sourceforge (sf.net)." "...we limited our data collection to projects that use only the Java programming language and were listed in the Internet and System Networking domains." "... only including these projects that use an OSI approved license..." "had to have posted at least one file on the Sourceforge site as of the time of our initial project selection Fall 2002" "Data were collected on the published release history of each project thatmet the screening criteria. Each release of each project was
analyzed to calculate CplXLCoh. The size of each release was measured using a calculation of the number of lines of code (LOC)"},
	pages = {167-178},
	publisher = {Institute of Mathematical Statistics},
	abstract = {This paper explores the application of functional data analysis (FDA) as a means to study the dynamics of software evolution in the open source context. Several challenges in analyzing the data from software projects are discussed, an approach to overcoming those challenges is described, and preliminary results from the analysis of a sample of open source software (OSS) projects are provided. The results demonstrate the utility of FDA for uncovering and categorizing multiple distinct patterns of evolution in the complexity of OSS projects. These results are promising in that they demonstrate some patterns in which the complexity of software decreased as the software grew in size, a particularly novel result. The paper reports preliminary explorations of factors that may be associated with decreasing complexity patterns in these projects. The paper concludes by describing several next steps for this research project as well as some questions for which more sophisticated analytical techniques may be needed.},
	keywords = {complexity, evolution, fda, java, lines of code, loc, release history, scm, size, sourceforge},
	issn = {08834237},
	url = {http://www.jstor.org/stable/27645747},
	author = {Stewart, Katherine J. and Darcy, David P. and Daniel, Sherae L.}
}
@conference {Gorg:2005:EDR:1083142.1083148,
	title = {Error detection by refactoring reconstruction},
	booktitle = {Proceedings of the 2005 international workshop on Mining software repositories},
	series = {MSR {\textquoteright}05},
	year = {2005},
	pages = {29-33},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {In many cases it is not sufficient to perform a refactoring only at one location of a software project. For example, refactorings may have to be performed consistently to several classes in the inheritance hierarchy, e.g. subclasses or implementing classes, to preserve equal behavior.In this paper we show how to detect incomplete refactorings - which can cause long standing bugs because some of them do not cause compiler errors - by analyzing software archives. To this end we reconstruct the class inheritance hierarchies, as well as refactorings on the level of methods. Then, we relate these refactorings to the corresponding hierarchy in order to find missing refactorings and thus, errors and inconsistencies that have been introduced in a software project at some point of the history.Finally. we demonstrate our approach by case studies on two open source projects.},
	keywords = {bugs, class, inheritance, jedit, refactoring, tomcat},
	isbn = {1-59593-123-6},
	doi = {http://doi.acm.org/10.1145/1082983.1083148},
	url = {http://doi.acm.org/10.1145/1082983.1083148},
	attachments = {https://flosshub.org/sites/flosshub.org/files/29ErrorDetection.pdf},
	author = {G{\"o}rg, Carsten and Wei{\ss}gerber, Peter}
}
@article {vanWendeldeJoode2005109,
	title = {Handling variety: the tension between adaptability and interoperability of open source software},
	journal = {Computer Standards \& Interfaces},
	volume = {28},
	number = {1},
	year = {2005},
	note = {unable to find concise description of the data used [ms]},
	pages = {109 - 121},
	abstract = {Open source software (OSS) offers unprecedented opportunities to create variety. This could lead to incompatibility and fragmentation. To prevent this some form of coordination is needed. This paper explores which mechanisms of coordination are responsible for limiting divergence in OSS. Two cases are examined: Java and Linux. A systematic difference seems to exist between the mechanisms identified in the two communities. With respect to Java, divergence is where possible avoided ex ante, whereas for Linux divergence is foremost reduced ex post. The conclusion discusses this difference and the implications of both types of coordination in respect to interoperability.},
	keywords = {coordination, divergence, java, linux},
	issn = {0920-5489},
	doi = {DOI: 10.1016/j.csi.2004.12.004},
	url = {http://www.sciencedirect.com/science/article/B6TYV-4F6K72H-1/2/c74c64ce51e6f46abf9f39ae945c9e15},
	author = {Ruben van Wendel de Joode and Tineke M. Egyedi}
}
@conference {777,
	title = {Live! I-Learn @ Home},
	booktitle = {OSS2005: Open Source Systems },
	year = {2005},
	pages = {294-295},
	abstract = {In this paper we present a live CD based on GNU/Linux (Knoppix), customized in order to supply a complete working and studying environment for the students of the Corso di Studi in Informatica. In particular, it supplies the Moodle course management system for e-learning complete of the courses of the first year. The aim is to enable the use of such resources off-line and without requiring special skills that will be achieved by studying but that newbies do not have.},
	keywords = {e-learning, environment, GNU/Linux, java, open source, technology},
	url = {http://pascal.case.unibz.it/handle/2038/977},
	author = {Baldoni, Matteo and Baroglio, Cristina and Roversi, Luca and Grandi, Claudio}
}
@conference {1054,
	title = {LASER: a lexical approach to analogy in software reuse},
	booktitle = {International Workshop on Mining Software Repositories (MSR 2004)},
	volume = {2004},
	year = {2004},
	pages = {112 - 116},
	publisher = {IEE},
	organization = {IEE},
	address = {Edinburgh, Scotland, UK},
	abstract = {Software reuse is the process of creating a software system from existing software components, rather than creating it from scratch. With the increase in size and complexity of existing software repositories, the need to provide intelligent support to the programmer becomes more pressing. An analogy is a comparison of certain similarities between things which are otherwise unlike. This concept has shown to be valuable in developing UML-level reuse techniques. In the LASER project we apply lexically-driven Analogy at the code level, rather than at the UML-level, in order to retrieve matching components from a repository of existing components. Using the lexical ontology Word-Net, we have conducted a case study to assess if class and method names in open source applications are used in a semantically meaningful way. Our results demonstrate that both hierarchical reuse and parallel reuse can be enhanced through the use of lexically-driven Analogy.},
	keywords = {class, developers, functions, jrefactory, method, naming, natural language, reuse, source code, wordnet},
	doi = {10.1049/ic:20040487},
	attachments = {https://flosshub.org/sites/flosshub.org/files/112LASER.pdf},
	author = {Amin, R. and Mel O Cinneide and Veale, Tony}
}
@article {Chen:2004:OCL:990374.990391,
	title = {Open-Source Change Logs},
	journal = {Empirical Softw. Engg.},
	volume = {9},
	year = {2004},
	note = {"We decided to compare actual differences in the source code with entries in the ChangeLog file. We used lxr, the Linux cross-referencing tool..., to determine the precise differences between two successive software versions. We then compared these differences with the records in the ChangeLog file to check the completeness of the ChangeLog file."
},
	month = {September},
	pages = {197{\textendash}210},
	publisher = {Kluwer Academic Publishers},
	address = {Hingham, MA, USA},
	abstract = {A recent editorial in Empirical Software Engineering suggested that open-source software projects offer a great deal of data that can be used for experimentation. These data not only include source code, but also artifacts such as defect reports and update logs. A common type of update log that experimenters may wish to investigate is the ChangeLog, which lists changes and the reasons for which they were made. ChangeLog files are created to support the development of software rather than for the needs of researchers, so questions need to be asked about the limitations of using them to support research. This paper presents evidence that the ChangeLog files provided at three open-source web sites were incomplete. We examined at least three ChangeLog files for each of three different open-source software products, namely, GNUJSP, GCC-g++, and Jikes. We developed a method for counting changes that ensures that, as far as possible, each individual ChangeLog entry is treated as a single change. For each ChangeLog file, we compared the actual changes in the source code to the entries in the ChangeLog file and discovered significant omissions. For example, using our change-counting method, only 35 of the 93 changes in version 1.11 of Jikes appear in the ChangeLog file{\textemdash}that is, over 62\% of the changes were not recorded there. The percentage of omissions we found ranged from 3.7 to 78.6\%. These are significant omissions that should be taken into account when using ChangeLog files for research. Before using ChangeLog files as a basis for research into the development and maintenance of open-source software, experimenters should carefully check for omissions and inaccuracies.},
	keywords = {change log, gcc, GCC-g, GNUJSP, Jikes, log files, Open-source software, source code},
	issn = {1382-3256},
	doi = {10.1023/B:EMSE.0000027779.70556.d0},
	url = {http://portal.acm.org/citation.cfm?id=990374.990391},
	attachments = {https://flosshub.org/sites/flosshub.org/files/chen.pdf},
	author = {Chen, Kai and Schach, Stephen R. and Yu, Liguo and Offutt, Jeff and Heller, Gillian Z.}
}
@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.}
}
@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.}
}
@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.}
}
@conference {1146,
	title = {Taxonomy of Open Source Software Development},
	booktitle = {1st Workshop on Open Source Software Engineering at ICSE 2001},
	year = {2001},
	keywords = {jun, linux, postgresql, wingnut},
	attachments = {https://flosshub.org/sites/flosshub.org/files/nakakojiyamamoto.PDF},
	author = {Nakakoji, K. and Yamamoto, Y.}
}
