@proceedings {1902,
	title = {Assessing Code Authorship: The Case of the Linux Kernel},
	volume = {496},
	year = {2017},
	month = {05/2017},
	pages = {151-163},
	publisher = {Springer},
	abstract = {Code authorship is a key information in large-scale open-source systems. Among others, it allows maintainers to assess division of work and identify key collaborators. Interestingly, open-source communities lack guidelines on how to manage authorship. This could be mitigated by setting to build an empirical body of knowledge on how authorship-related measures evolve in successful open-source communities. Towards that direction, we perform a case study on the Linux kernel. Our results show that: (a) only a small portion of developers (26\%) makes significant contributions to the code base; (b) the distribution of the number of files per author is highly skewed{\textemdash}a small group of top-authors (3\%) is responsible for hundreds of files, while most authors (75\%) are responsible for at most 11 files; (c) most authors (62\%) have a specialist profile; (d) authors with a high number of co-authorship connections tend to collaborate with others with less connections.},
	keywords = {code authorship, developer network, linux kernel},
	doi = {10.1007/978-3-319-57735-7_15},
	url = {https://link.springer.com/chapter/10.1007/978-3-319-57735-7_15},
	author = {Guilherme Avelino and Passos, Leonardo and Andre Hora and Marco Tulio Valente}
}
@proceedings {export:232407,
	title = {The Uniqueness of Changes: Characteristics and Applications},
	year = {2015},
	month = {05/2015},
	abstract = {Changes in software development come in many forms. Some changes are frequent, idiomatic, or repetitive (e.g. adding checks for nulls or logging important values) while others are unique. We hypothesize that unique changes are different from the more common similar (or non-unique) changes in important ways; they may require more expertise or represent code that is more complex or prone to mistakes. As such, these changes are worthy of study. In this paper, we present a definition of unique changes and provide a method for identifying them in software project history. Based on the results of applying our technique on the Linux kernel and two large projects at Microsoft, we present an empirical study of unique changes. We explore how prevalent unique changes are and characterize where they occur along the architecture of the project. We further investigate developers{\textquoteright} contribution towards uniqueness of changes. We also describe potential applications of leveraging the uniqueness of change and implement two such applications, evaluating the risk of changes based on uniqueness and providing change recommendations for non-unique changes.},
	keywords = {linux kernel},
	url = {http://research.microsoft.com/apps/pubs/default.aspx?id=232407},
	attachments = {https://flosshub.org/sites/flosshub.org/files/MSR-TR-2014-149.pdf},
	author = {Ray, Baishakhi and Meiyappan Nagappan and Christian Bird and Nachiappan Nagappan and Zimmermann, Thomas}
}
@conference {Guo:2014:ODC:2597073.2597094,
	title = {Oops! Where Did That Code Snippet Come from?},
	booktitle = {Proceedings of the 11th Working Conference on Mining Software Repositories},
	series = {MSR 2014},
	year = {2014},
	pages = {52{\textendash}61},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {A kernel oops is an error report that logs the status of the Linux kernel at the time of a crash. Such a report can provide valuable first-hand information for a Linux kernel maintainer to conduct postmortem debugging. Recently, a repository has been created that systematically collects kernel oopses from Linux users. However, debugging based on only the information in a kernel oops is difficult. We consider the initial problem of finding the offending line, i.e., the line of source code that incurs the crash. For this, we propose a novel algorithm based on approximate sequence matching, as used in bioinformatics, to automatically pinpoint the offending line based on information about nearby machine-code instructions, as found in a kernel oops. Our algorithm achieves 92\% accuracy compared to 26\% for the traditional approach of using only the oops instruction pointer.},
	keywords = {debugging, linux kernel, oops, sequence alignment},
	isbn = {978-1-4503-2863-0},
	doi = {10.1145/2597073.2597094},
	url = {http://doi.acm.org/10.1145/2597073.2597094},
	attachments = {https://flosshub.org/sites/flosshub.org/files/guo.pdf},
	author = {Guo, Lisong and Lawall, Julia and Muller, Gilles}
}
@proceedings {1451,
	title = {Exploring the Role of Outside Organizations in Free / Open Source Software Projects},
	volume = {378},
	year = {2012},
	month = {09/2012},
	pages = {201-215},
	publisher = {IFIP AICT},
	abstract = {Free/Open Source Software (FOSS) projects have a reputation for being grass-roots efforts driven by individual contributors volunteering their time and effort. While this may be true for a majority of smaller projects, it is not always the case for large projects. As projects grow in size, importance and complexity, many come to depend on corporations, universities, NGO{\textquoteright}s and governments, for support and contributions, either financially or through seconded staff. As outside organizations get involved in projects, how does this affect their governance, transparency and direction? To study this question we gathered bug reports and commit logs for GCC and the Linux Kernel. We found that outside organizations contribute a majority of code but rarely participate in bug triaging. Therefore their code does not necessarily address the needs of others and may distort governance and direction. We conclude that projects should examine their dependence on outside organizations},
	keywords = {bug reports, commit, Community sustainability, Contributor affiliation, gcc, governance, linux kernel, Participation metrics},
	url = {http://research.engr.oregonstate.edu/hci/sites/research.engr.oregonstate.edu.hci/files/papers/forrest2012exploring.pdf},
	author = {Forrest, Darren and Jensen, Carlos and Mohan, Nitin and Davidson, Jennifer}
}
@article {1879,
	title = {Linux Kernel Development: How Fast it is Going, Who is Doing It, What They are Doing, and Who is Sponsoring It},
	year = {2012},
	month = {03/2012},
	institution = {The Linux Foundation},
	abstract = {The kernel which forms the core of the Linux system is the result of one of the largest cooperative software projects ever attempted. Regular 2-3 month releases deliver stable updates to Linux users, each with signi cant new features, added device support, and improved performance. The rate of change in the kernel is high and increasing, with between 8,000 and 12,000 patches going into each recent kernel release. These releases each contain the work of over 1,000 developers representing nearly 200 corporations.
Since 2005, over 7,800 individual developers from almost 800 different companies have contributed to the kernel. The Linux kernel, thus, has become a common resource developed on a massive scale by companies which are  erce competitors in other areas.
This is the fourth update of this document, which has been published roughly annually since 2008. It covers development through the 3.2 release, with an emphasis on the releases (2.6.36 to 3.2) made since the last update. It has been a busy period, with seven kernel releases created, many signi cant changes made, and continual growth of the kernel developer and user community.
},
	keywords = {corporate, corporations, developers, linux kernel, metrics},
	attachments = {https://flosshub.org/sites/flosshub.org/files/lf_kernel_development_2012.pdf},
	author = {Corbet, Jonathan and Greg Kroah-Hartman and Amanda McPherson}
}
@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}
}
@conference {Meneely:2011:SDN:1985793.1985832,
	title = {Socio-technical developer networks: should we trust our measurements?},
	booktitle = {Proceedings of the 33rd International Conference on Software Engineering},
	series = {ICSE {\textquoteright}11},
	year = {2011},
	pages = {281{\textendash}290},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {Software development teams must be properly structured to provide effectiv collaboration to produce quality software. Over the last several years, social network analysis (SNA) has emerged as a popular method for studying the collaboration and organization of people working in large software development teams. Researchers have been modeling networks of developers based on socio-technical connections found in software development artifacts. Using these developer networks, researchers have proposed several SNA metrics that can predict software quality factors and describe the team structure. But do SNA metrics measure what they purport to measure? The objective of this research is to investigate if SNA metrics represent socio-technical relationships by examining if developer networks can be corroborated with developer perceptions. To measure developer perceptions, we developed an online survey that is personalized to each developer of a development team based on that developer{\textquoteright}s SNA metrics. Developers answered questions about other members of the team, such as identifying their collaborators and the project experts. A total of 124 developers responded to our survey from three popular open source projects: the Linux kernel, the PHP programming language, and the Wireshark network protocol analyzer. Our results indicate that connections in the developer network are statistically associated with the collaborators whom the developers named. Our results substantiate that SNA metrics represent socio-technical relationships in open source development projects, while also clarifying how the developer network can be interpreted by researchers and practitioners.},
	keywords = {developer network, developers, linux, linux kernel, PHP, social network analysis, Survey, wireshark},
	isbn = {978-1-4503-0445-0},
	doi = {10.1145/1985793.1985832},
	url = {http://doi.acm.org/10.1145/1985793.1985832},
	author = {Meneely, Andrew and Williams, Laurie}
}
@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}
}
@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 {1206,
	title = {Collecting data from distributed FOSS projects},
	booktitle = {3rd Workshop on Public Data about Software Development (WoPDaSD 2008)},
	year = {2008},
	note = {"We selected three projects from the initial set of projects: Linux 2.6, an operating system kernel, gimp, a graphics program, and Blender, a 3d content creation suite."
"To acquire data from each data source, we wrote special programs based on the earlier prototypes....The first program extracts information from mailing list archives....The second program obtains bug reports from bug tracking systems....The third program obtains source code from network-accessible version control systems and runs metric calculations on it."},
	month = {2009},
	pages = {8-13},
	abstract = {A key trait of Free and Open Source Software (foss) development is its distributed nature. Nevertheless, two project-level operations, the fork and the merge of program code, are among the least well understood events in the lifespan of a foss project. Some projects have explicitly adopted these operations as the primary means of concurrent development. In this study, we examine the effect of highly distributed software development, as found in the Linux kernel project, on collection and modelling of software development data. We find that distributed development calls for sophisticated temporal modelling techniques where several versions of the source code tree can exist at once. Attention must be turned towards the methods of quality assurance and peer review that projects employ to manage these parallel source trees. Our analysis indicates that two new metrics, fork rate and merge rate, could be useful for determining the role of distributed version control systems in foss projects. The study 
presents a preliminary data set consisting of version control and mailing list data. },
	keywords = {bitkeeper, bug tracking system, cvs, distributed, email archive, fork rate, git, life cycle, linux, linux kernel, mailing list, merge rate, subversion, svn, version control},
	attachments = {https://flosshub.org/sites/flosshub.org/files/fagerholm.pdf},
	author = {Fagerholm, Fabian and Taina, Juha}
}
@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 {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 {1105,
	title = {Free \& Open Source Software Creation and {\textquoteleft}the Economy of Regard{\textquoteright}},
	booktitle = {Third EPIP Workshop},
	year = {2004},
	month = {04/2004},
	keywords = {linux, linux kernel, scm, source code},
	attachments = {https://flosshub.org/sites/flosshub.org/files/DalleDavidGhosh\%20Wolak.pdf},
	author = {Jean-Michel Dalle and Paul A. David and Rishab Ayer Ghosh and Frank A. Wolak}
}
@article {1113,
	title = {Release criteria for the Linux kernel},
	journal = {First Monday},
	volume = {9},
	number = {4},
	year = {2004},
	note = {"The first was to examine the change logs [10, 11, 12] that are submitted with the public release of a version of the kernel on www.kernel.org [1]. Observations were made on the release nomenclature used in both the 2.4.x series and the 2.5.x (which later became the 2.6.x series). The number of patches incorporated into each release and the elapsed time between releases was recorded. The second approach was to review the Linux kernel mailing list [2] for any evidence of criteria for performing a particular release including any metrics used, tests carried out or bug databases referenced."},
	month = {2004},
	abstract = {Before software is released to its users, software developers will ensure that the software has met specified functional and technical requirements and that it is as free from bugs as possible. Users should be able to have a high degree of confidence that the software will perform as specified and without fault. With open source development practices such as those employed on the Linux kernel project, there are no detailed specifications and little formal testing processes. The questions, then, are what criteria, if any, are used in determining the suitability for release of a particular version of this software, and do users have any degree of confidence in the quality of that release of software? These questions were examined in this study using information from the Linux Kernel Mailing List (LKML), the primary forum for discussion of development issues of the Linux kernel, and change logs submitted with version releases of the Linux kernel. It was determined that very little planning is employed in determining the release of a particular version of the software and that a version of the software is essentially a collection of source patches released at regular intervals with some stabilisation of the code base before each release. Very little attempt is made to verify that the code is bug free, and consequently, the code released is of a largely unknown level of quality. End users are left to decide for themselves the suitability and robustness of a particular version of the software.},
	keywords = {bugs, change log, linux, linux kernel, log files, mailing list, patches, quality, release history},
	url = {http://firstmonday.org/htbin/cgiwrap/bin/ojs/index.php/fm/article/view/1136/1056},
	attachments = {https://flosshub.org/sites/flosshub.org/files/Glance.pdf},
	author = {Glance, D.G.}
}
@article {flosswp103,
	title = {Contributing to the common pool resources in Open Source software. A comparison between individuals and firms},
	year = {2003},
	month = {August},
	abstract = {This paper studies the contributions to Open Source projects of software firms. Our goal is to analyse whether they follow the same regularities that characterize the behaviour of individual programmers. An exhaustive empirical analysis is carried out using data on project membership, project coordination and contribution efforts of 146 Italian firms that do business with Open Source software. We follow a meta-analytic approach comparing our findings with the results of the surveys conducted on Free Software programmers. Moreover, the availability of the data gathered by Hertel et al. (2003) on 141 developers of the Linux kernel will allow direct comparisons between the two sets.},
	keywords = {developers, linux, linux kernel, Survey},
	attachments = {https://flosshub.org/sites/flosshub.org/files/bnaccorsirossidevelopers.pdf},
	author = {Andrea Bonaccorsi}
}
@article {2003,
	title = {From a Firm-Based to a Community-Based Model of Knowledge Creation: The Case of the Linux Kernel Development},
	journal = {Organization Science},
	volume = {14},
	number = {6},
	year = {2003},
	note = {"we study the Linux development community mainly by analyzing the artifacts that the Linux developers have produced. A key output of knowledge creation activities is the artifacts. The most important artifact, of course, is the Linux operating system source code."
"Along with the source code, a "Credits" text file and a "MAINTAINERS" text file are distributed to the users."
"An equally important artifact is the development activities archived in the Linux-kernel mailing list"..."Using the weekly Linux-kernel email archive for years 1995 to 2000 as a key source of data, we focus on people who have sent at least one email to the Linux-kernel mailing list. "
"In addition, we examine the developers{\textquoteright} demographic distributions, working patterns, and motivations by analyzing the raw data from an on-line survey"},
	pages = {pp. 633-649},
	publisher = {INFORMS},
	abstract = {We propose a new model of knowledge creation in purposeful, loosely coordinated, distributed systems, as an alternative to a firm-based one. Specifically, using the case of the Linux kernel development project, we build a model of community-based, evolutionary knowledge creation to study how thousands of talented volunteers, dispersed across organizational and geographical boundaries, collaborate via the Internet to produce a knowledge-intensive, innovative product of high quality. By comparing and contrasting the Linux model with the traditional/commercial model of software development and firm-based knowledge creation efforts, we show how the proposed model of knowledge creation expands beyond the boundary of the firm. Our model suggests that the product development process can be effectively organized as an evolutionary process of learning driven by criticism and error correction. We conclude by offering some theoretical implications of our community-based model of knowledge creation for the literature of organizational learning, community life, and the uses of knowledge in society.},
	keywords = {credits, developers, email, email archives, knowledge creation, linux kernel, mailing list, maintainers, scm, source code, Survey, Volunteers},
	issn = {10477039},
	url = {http://www.jstor.org/stable/4135125},
	author = {Lee, Gwendolyn K. and Cole, Robert E.}
}
@article {flosswp124,
	title = {Maintainability of the Linux Kernel},
	journal = {Proceedings of the 2nd Workshop on Open Source Software Engineering ICSE2002},
	year = {2003},
	note = {"We have examined 365 versions of Linux.  For every version, we counted the number of 
instances of common (global) coupling between each of the 17 kernel modules and all the other 
modules in that version of Linux."},
	month = {October},
	abstract = {We have examined 365 versions of Linux. For every version, we counted the number of instances of common (global) coupling between each of the 17 kernel modules and all the other modules in that version of Linux. We found that the number of instances of common coupling grows exponentially with version number. This result is significant at the 99.99\% level, and no additional variables are needed to explain this increase. We conclude that, unless Linux is restructured with a bare minimum of common coupling, the dependencies induced by common coupling will, at some future date, make Linux exceedingly hard to maintain without inducing regression faults.},
	keywords = {coupling, kernel, linux, linux kernel, modules, source code},
	attachments = {https://flosshub.org/sites/flosshub.org/files/linux-maint_0.pdf},
	author = {Schach, Stephen R. and Jin, B. and Wright, D.R.}
}
@conference {1163,
	title = {On the Nonmaintainability of Open-Source Software},
	booktitle = {Proceedings of the 2nd ICSE Workshop on Open Source},
	year = {2002},
	note = {"We downloaded 365 versions of Linux. For each version in turn, we examined the 17 kernel modules and counted the number of lines of code in each module. Then we counted the number of instances of common (global) coupling between each of the kernel modules and all the other modules in that version of Linux. We obtained two primary results."},
	keywords = {Common coupling, coupling, lines of code, linux, linux kernel, loc, metrics},
	attachments = {https://flosshub.org/sites/flosshub.org/files/SchachOffutt.pdf},
	author = {Schach, Stephen R. and Offutt, Jeff}
}
@conference {1154,
	title = {Version Control: A Case Study in the Challenges and Opportunities for Open Source Software Development},
	booktitle = {Proceedings of the 2nd ICSE Workshop on Open Source},
	year = {2002},
	abstract = {The growth of the worldwide open source development effort, driven in part by the recent entrance of large corporations into the open source arena, offers new opportunities to improve the software engineering tools available for that effort. Indeed, the increasing difficulty of managing large open source projects, as well as that of integrating related efforts into new programming environments, represents a challenge that must be met if the rapid growth of open source software is to continue. This position paper addresses these issues in the context of software version control.},
	keywords = {cvs, kernel, linux, linux kernel, version control},
	attachments = {https://flosshub.org/sites/flosshub.org/files/ChuCarrollShieldsWright.pdf},
	author = {Chu-Carroll, M.C. and Sheilds, D. and Wright, J.}
}
@conference {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 {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.}
}
@conference {Godfrey:2000:EOS:850948.853411,
	title = {Evolution in Open Source Software: A Case Study},
	booktitle = {Proceedings of the International Conference on Software Maintenance (ICSM{\textquoteright}00)},
	series = {ICSM {\textquoteright}00},
	year = {2000},
	note = {"We examined 96 kernel versions..."
.c files, .h files only
loc, lines of code
number of functions
number of modules},
	pages = {131{\textendash}},
	publisher = {IEEE Computer Society},
	organization = {IEEE Computer Society},
	address = {Washington, DC, USA},
	abstract = {Most studies of software evolution have been performed on systems developed within a single company using traditional management techniques. With the widespread availability of several large software systems that have been developed using an {\textquoteright}open source{\textquoteright} development approach, we now have a chance to examine these systems in detail, and see if their evolutionary narratives are significantly different from commercially developed systems. This paper summarizes our preliminary investigations into the evolution of the best known open source system: the Linux operating system kernel. Because Linux is large (over two million lines of code in the most recent version) and because its development model is not as tightly planned and managed as most industrial software processes, we had expected to find that Linux was growing more slowly as it got bigger and more complex. Instead, we have found that Linux has been growing at a super-linear rate for several years. In this paper, we explore the evolution of the Linux kernel both at the system level and within the major subsystems, and we discuss why we think Linux continues to exhibit such strong growth.},
	keywords = {evolution, functions, growth, lines of code, linux, linux kernel, loc, source code},
	isbn = {0-7695-0753-0},
	url = {http://portal.acm.org/citation.cfm?id=850948.853411},
	attachments = {https://flosshub.org/sites/flosshub.org/files/godfrey00.pdf},
	author = {Godfrey, Michael W. and Tu, Qiang}
}
