Assurance Evaluation for OSS Adoption in a Telco Context - Ardagna, Claudio; Banzi, Massimo; Damiani, Ernesto; El Ioini, Nabil; Frati, Fulvio (OSS2009: Open Source Ecosystems: Diverse Communities Interacting (IFIP 2.13), 2009)
Software Assurance (SwA) is a complex concept that involves different stages of a software development process and may be defined differently depending on its focus, as for instance software quality, security, or dependability. In Computer Science, the term assurance is referred to all activities necessary to provide enough confidence that a software product will satisfy its users’ functional and non-functional requirements.

Author entropy vs. file size in the GNOME suite of applications - Casebolt, Jason R.; Krein, Jonathan L.; MacLean, Alexander C.; Knutson, Charles D.; Delorey, Daniel P. (2009 6th IEEE International Working Conference on Mining Software Repositories (MSR)2009 6th IEEE International Working Conference on Mining Software Repositories, 2009)
We present the results of a study in which author entropy was used to characterize author contributions per file. Our analysis reveals three patterns: banding in the data, uneven distribution of data across bands, and file size dependent distributions within bands. Our results suggest that when two authors contribute to a file, large files are more likely to have a dominant author than smaller files.
Keywords: author entropy; contributions; gnome; msr challenge

Automatic labeling of software components and their evolution using log-likelihood ratio of word frequencies in source code - Kuhn, Adrian (2009 6th IEEE International Working Conference on Mining Software Repositories (MSR)2009 6th IEEE International Working Conference on Mining Software Repositories, 2009)
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

Benchmarking Lightweight Techniques to Link E-Mails and Source Code - Bacchelli, Alberto; D'Ambros, Marco; Lanza, Michele; Robbes, Romain (2009 16th Working Conference on Reverse Engineering, 2009)
During the evolution of a software system, a large amount of information, which is not always directly related to the source code, is produced. Several researchers have provided evidence that the contents of mailing lists represent a valuable source of information: Through e-mails, developers discuss design decisions, ideas, known problems and bugs, etc. which are otherwise not to be found in the system. A technical challenge in this context is how to establish the missing link between free-form e-mails and the system artifacts they refer to. Although the range of approaches is vast, establishing their accuracy remains a problem, as there is no benchmark against which to compare their performance. To overcome this issue, we manually inspected a statistically significant number of e-mails pertaining to the ArgoUML system. Based on this benchmark, we present a variety of lightweight techniques to assign e-mails to software artifacts and measure their effectiveness in terms of precision and recall.
Keywords: argouml; email; mailing lists

Beyond the Business Model: Incentives for Organizations to Publish Software Source Code - Juho Lindman; Juutilainen, Juha-Pekka; Rossi, Matti (OSS2009: Open Source Ecosystems: Diverse Communities Interacting (IFIP 2.13), 2009)
The software stack opened under Open Source Software (OSS) licenses is growing rapidly. Commercial actors have released considerable amounts of previously proprietary source code. These actions beg the question why companies choose a strategy based on giving away software assets? Research on outbound OSS approach has tried to answer this question with the concept of the “OSS business model”. When studying the reasons for code release, we have observed that the business model concept is too generic to capture the many incentives organizations have. Conversely, in this paper we investigate empirically what the companies’ incentives are by means of an exploratory case study of three organizations in different stages of their code release. Our results indicate that the companies aim to promote standardization, obtain development resources, gain cost savings, improve the quality of software, increase the trustworthiness of software, or steer OSS communities. We conclude that future research on outbound OSS could benefit from focusing on the heterogeneous incentives for code release rather than on revenue models.

Bridging the Gap between Agile and Free Software Approaches - Paul J. Adams; Capiluppi, Andrea (International Journal of Open Source Software and Processes, 2009)
Agile sprints are short events where a small team collocates in order to work on particular aspects of the overall project for a short period of time. Sprinting is a process that has been observed also in Free Software projects: these two paradigms, sharing common principles and values have shown several commonalities of practice. This article evaluates the impact of sprinting on a Free Software project through the analysis of code repository logs: sprints from two Free Software projects (Plone and KDE PIM) are assessed and two hypotheses are formulated: do sprints increase productivity? Are Free Software projects more productive after sprints compared with before? The primary contribution of this article is to show how sprinting creates a large increase in productivity both during the event, and immediately after the event itself: this argues for more in-depth studies focussing on the nature of sprinting.
Keywords: agile; kde; lines of code; loc; plone; productivity; scm; scrum; sprints; subversion

The Case Study of an F/OSS Virtualization Platform Deployment and Quantitative Results - Stathopoulos, Panagiotis; Soumplis, Alexandros; Houssos, Nikos (OSS2009: Open Source Ecosystems: Diverse Communities Interacting (IFIP 2.13), 2009)
In this paper we present practical experiences and results from the deployment of an F/OSS virtualization platform. EKT’s (NDC) core IT infrastructure was transformed to a virtualized one, using exclusively F/OSS, while severe budget and timing constraints were in place. This migration was initiated in order to better cope with EKT’s services requirements, while accommodating at the same time the need for the in house development of a large scale open access infrastructure. The benefits derived from this migration were not only generic virtualization benefits, such as the quantifiable reduced power consumption and cost reduction through consolidation, but also F/OSS virtualization specific ones.

Challenges of the Open Source Component Marketplace in the Industry - Ayala, Claudia; Hauge, Øyvind; Conradi, Reidar; Franch, Xavier; Li, Jingyue; Velle, Ketil (OSS2009: Open Source Ecosystems: Diverse Communities Interacting (IFIP 2.13), 2009)
The reuse of Open Source Software components available on the Internet is playing a major role in the development of Component Based Software Systems. Nevertheless, the special nature of the OSS marketplace has taken the “classical” concept of software reuse based on centralized repositories to a completely different arena based on massive reuse over Internet. In this paper we provide an overview of the actual state of the OSS marketplace, and report preliminary findings about how companies interact with this marketplace to reuse OSS components. Such data was gathered from interviews in software companies in Spain and Norway. Based on these results we identify some challenges aimed to improve the industrial reuse of OSS components.

Choosing Open Source ERP Systems: What Reasons Are There For Doing So? - Johansson, Björn; Sudzina, Frantisek (OSS2009: Open Source Ecosystems: Diverse Communities Interacting (IFIP 2.13), 2009)
Enterprise resource planning (ERP) systems attract a high attention and open source software does it as well. The question is then if, and if so, when do open source ERP systems take off. The paper describes the status of open source ERP systems. Based on literature review of ERP system selection criteria based on Web of Science articles, it discusses reported reasons for choosing open source or proprietary ERP systems. Last but not least, the article presents some conclusions that could act as input for future research. The paper aims at building up a foundation for the basic question: What are the reasons for an organization to adopt open source ERP systems.

Code siblings: Technical and legal implications of copying code between applications - Daniel M. German; Di Penta, Massimiliano; Gueheneuc, Yann-Gael; Antoniol, Giuliano (2009 6th IEEE International Working Conference on Mining Software Repositories (MSR)2009 6th IEEE International Working Conference on Mining Software Repositories, 2009)
Source code cloning does not happen within a single system only. It can also occur between one system and another. We use the term code sibling to refer to a code clone that evolves in a different system than the code from which it originates. Code siblings can only occur when the source code copyright owner allows it and when the conditions imposed by such license are not incompatible with the license of the destination system. In some situations copying of source code fragments are allowed - legally - in one direction, but not in the other. In this paper, we use clone detection, license mining and classification, and change history techniques to understand how code siblings - under different licenses - flow in one direction or the other between Linux and two BSD Unixes, FreeBSD and OpenBSD. Our results show that, in most cases, this migration appears to happen according to the terms of the license of the original code being copied, favoring always copying from less restrictive licenses towards more restrictive ones. We also discovered that sometimes code is inserted to the kernels from an outside source.
Keywords: bsd; fossology; freebsd; linux; openbsd; source code

Collaboration in Open Source Domains - Görkem Çetin; Göktürk, Mehmet (International Journal of Open Source Software and Processes, 2009)
Free and open source software (F/OSS) developers have a tendency to build feature-centric projects rather than following a user-centered design, ignoring the necessity of usability in the resulting product. While there are many reasons behind this, the main cause can be stated as the lack of awareness of usability from developers’ point of view and little interaction of project stakeholders with Human-Computer Interaction (HCI) studies. This chapter examines different types of collaboration methods of usability experts and developers focusing particularly on open source projects, together with potential issues envisaged during the communication phases. The chapter also focuses on the collaboration trends and patterns of HCI experts, developers and users with an emphasis on concerns related to inefficient exploitation of current tools and technologies and provide an open usability engineering method which could be exploited in distributed projects

Collaborative Software Development Using R-Forge - Stefan Theußl; Achim Zeileis (The R Journal, 2009)
Open source software (OSS) is typically created in a decentralized self-organizing process by a community of developers having the same or similar interests (see the famous essay by Raymond, 1999). A key factor for the success of OSS over the last two decades is the Internet: Developers who rarely meet face-to-face can employ new means of communication, both for rapidly writing and deploying software (in the spirit of Linus Torvald’s “release early, release often paradigm”). Therefore, many tools emerged that assist a collaborative software development process, including in particular tools for source code management (SCM) and version control. In the R world, SCM is not a new idea; in fact, the R Development Core Team has always been using SCM tools for the R sources, first by means of Concurrent Versions System (CVS, see Cederqvist et al., 2006), and then via Subversion (SVN, see Pilato et al., 2004). A central repository is hosted by ETH Zürich mainly for managing the development of the base R system. Mailing lists like R-help, R-devel and many others are currently the main communication channels in the R community. First, we present the core features that R- Forge offers to the R community. Second, we give a hands-on tutorial on how users and developers can get started with R-Forge. In particular, we illustrate how people can register, set up new projects, use R- Forge’s SCM facilities, provide their packages on R-Forge, host a project-specific website, and how package maintainers submit a package to the Compre- hensive R Archive Network (CRAN, http://CRAN. R-project.org/). Finally, we summarize recent developments and give a brief outlook to future work.
Keywords: forge; R; scm; source code repositories; statistics

The Commit Size Distribution of Open Source Software - Arafat, O.; Dirk Riehle (2009 42nd Hawaii International Conference on System Sciences (HICSS 2009), 2009)
With the growing economic importance of open source, we need to improve our understanding of how open source software development processes work. The analysis of code contributions to open source projects is an important part of such research. In this paper we analyze the size of code contributions to more than 9,000 open source projects. We review the total distribution and distinguish three categories of code contributions using a size-based heuristic: single focused commits, aggregate team contributions, and repository refactorings. We find that both the overall distribution and the individual categories follow a power law. We also suggest that distinguishing these commit categories by size will benefit future analyses.
Keywords: commits; configuration management; history; lines of code; sloc; source code

Communication Network Characteristics of Open Source Communities - Hinds, David; Lee, Ronald M. (International Journal of Open Source Software and Processes, 2009)
Empirical research has shown that social network structure is a critical success factor for various kinds of work groups. The authors extended this research to a new type of work group—the open source software project community—with the objective of exploring the role of communication networks within these intriguing projects. Using archival data from 143 open source project groups, the authors compiled six measures of social network structure and analyzed these in relation to four measures of group success. This study found that the social network structures of these project communities did not appear to be critical success factors at all, but rather they had no significant impact on success or their effect was opposite of that seen in prior studies of work groups. Various conjectures were suggested that might explain these results, offering opportunities for further research.

Competition and production of digital public goods - Radtke, Nicholas P.; Janssen, Marco A. (International Journal of Intelligent Control and Systems, 2009)
With the Internet has come the phenomenon of people volunteering to work on digital public goods such as open source software and online encyclopedia articles. Presumably, the success of individual public goods has an effect on attracting volunteers. However, the definition of success is ill-defined. This paper explores the impact of different success metrics on a simple public goods model. The findings show that the different success metrics considered do have an impact on the behavior of the model, with the largest differences being between consumer-oriented and producer-oriented metrics. This indicates that many proposed success metrics may be mapped into one of these two categories and within a category, all success metrics measure the same phenomenon. We argue that the characteristics of producer-oriented metrics more closely match real world phenomena, indicating that public goods are driven by producer, and not consumer, interests.
Keywords: digital public goods; FLOSS; open source software; sourceforge; success metrics; wikipedia

Consumer Welfare and Market Structure in a Model of Competition between Open Source and Proprietary Software - Gaudeul, Alexia (International Journal of Open Source Software and Processes, 2009)
I consider a Vickrey-Salop model of spatial product differentiation with quasi-linear utility functions and contrast two modes of production, the proprietary model where entrepreneurs sell software to the users, and the open source model where users participate in software development. I show that the OS model of production may be more efficient from the point of view of welfare than the proprietary model, but that an OS industry is vulnerable to entry by entrepreneurs while a proprietary industry can resist entry by OS projects. A mixed industry where OS and proprietary development methods coexist may exhibit large OS projects cohabiting with more specialized proprietary projects, and is more efficient than the proprietary model of production from the point of view of welfare.

A Cost Model of Open Source Software Adoption - Russo, Barbara; Succi, Giancarlo (International Journal of Open Source Software and Processes, 2009)
A limited budget for IT may lock public bodies in obsolete inefficient solutions slowing down their process of innovation. Various actions of estimating, controlling, and reducing IT costs have been already performed at national and European levels and Open Source Software (OSS) has been often pointed as a promising alternative that may also render public services and the underlying business processes more transparent and accessible to citizens. In this chapter, we propose a model of cost of a migration to OSS as a decision making instrument that helps public bodies being autonomous and independent in the IT adoption. The model is empirically validated in the real daily operations of more than 3,500 users. If adopted systematically our model might be a powerful tool to support transformational government and to establish an empirical open knowledge base on the economic advantages of OSS on which to found future strategies of OSS adoption.

Customization of Open Source Software in Companies - Keßler, Steffen; Alpar, Paul (OSS2009: Open Source Ecosystems: Diverse Communities Interacting (IFIP 2.13), 2009)
Most papers related to Open Source Software (OSS) discuss the development of OSS, licensing issues, and motivations of developers. Research in the area of customization of OSS is rare, however. The process after the deployment of an OSS within a company remains unknown. There is a danger that it is often unstructured and error-prone since OSS develops in a more complex way than proprietary software. Based on our literature study, modifications of open source code do occur also in organizations outside of the software industry. Customization of applications is more common than customization of infrastructure software in these organizations. Therefore, we examine the process of deployment and adaptation of an OSS application software over several update iterations in great detail. This examination shows that this process has similarities with the process of deployment of proprietary software but it also exhibits important differences. Based on this case study, we also suggest a process model for customization of OSS applications in user organizations.

Design Evolution of an Open Source Project Using an Improved Modularity Metric - Milev, Roberto; Muegge, Steven; Weiss, Michael (OSS2009: Open Source Ecosystems: Diverse Communities Interacting (IFIP 2.13), 2009)
Modularity of an open source software code base has been associated with community growth, incentives for voluntary contribution, and a reduction in free riding. As a theoretical construct, it links open source software to other domains of research, including organization theory, the economics of industry structure, and new product development; however, measuring the modularity of an open source software design has proven difficult, especially for large and complex systems. Building on previous work on Design Structure Matrices (DSMs), this paper describes two contributions towards a method for examining the evolving modularity of large-scale software systems: (1) an algorithm and new modularity metric for comparing code bases of different size; and (2) evolution analysis of Apache Tomcat to illustrate the insights gained from this approach. Over a ten-year period, the modularity of Tomcat continually increased, except in three instances: with each major change to the architecture or implementation, modularity first declined, then increased in the subsequent version to fully compensate for the decline.

Design Information Sharing Across Multiple Knowledge Systems in a FLOSS Community - Bach, Paula (iConference '09, 2009)
This paper explores support for design information sharing between the distinct knowledge systems and skill sets of interactive system designers and developers. The paper focuses on the challenges of sharing information among groups of designers, developers, and users with multiple knowledge systems in the context of free/libre/open source software (FLOSS) communities. Bringing design to FLOSS communities introduces new knowledge into a solitary community of practice, and discussion ensues about how exploiting the 'symmetry of ignorance' can enhance information sharing through design in CodePlex, an open source project hosting community website. Finally, design mockups illustrate how CodePlex serves as a boundary object supporting design information sharing across distinct knowledge systems.
Keywords: codeplex; developers; information sharing

Determinants of open source software project success: A longitudinal study - Subramaniam, Chandrasekar; Sen, Ravi; Nelson, Matthew L. (Decis. Support Syst., 2009)
In this paper, we investigate open source software (OSS) success using longitudinal data on OSS projects. We find that restrictive OSS licenses have an adverse impact on OSS success. On further analysis, restrictive OSS license is found to be negatively associated with developer interest, but is positively associated with the interest of non-developer users and project administrators. We also show that developer and non-developer interest in the OSS project and the project activity levels in any time period significantly affect the project success measures in subsequent time period. The implications of our findings for OSS research and practice are discussed.
Keywords: contributors; developers; licenses; longitudinal study; Open source project; OSS; project success; restrictive; Software project success

Discourses on User Participation - Iivari, Netta (International Journal of Open Source Software and Processes, 2009)
Users should participate in information technology (IT) artifact development, but it has proven to be challenging. This applies also in the open source software (OSS) development. This chapter critically examines discursive construction of user participation in academic literatures and in practice, in IT artifact development. First three academic discourses constructing user participation are discussed. Then the discursive construction of user participation is explored in OSS development literature. Afterwards, results from several empirical, interpretive case studies are outlined. Some of them have been carried out in the IT artifact product development organizations, others in the OSS development context. Clear similarities can be identified in the discourses constructing user participation in these divergent IT artifact development contexts. The academic discourses on user participation clearly also legitimate certain ways of constructing user participation in practice. The OSS development literature bears resemblance mainly with the Human Computer Interaction (HCI) discourse on user participation. Therefore, it is argued that especially the HCI community should carefully reflect on what kinds of discourses on user participation it advocates and deems as legitimate.

Domain Drivers in the Modularization of FLOSS Systems - Capiluppi, Andrea (OSS2009: Open Source Ecosystems: Diverse Communities Interacting (IFIP 2.13), 2009)
The classification of software systems into types has been achieved in the past by observing both their specifications and behavioral patterns: the SPE classification, for instance, and its further supplements and refinements, has identified the S-type (i.e., fully specified), the P-type (i.e., specified but dependent on the context) and the E-type (i.e., addressing evolving problems) among the software systems. In order to detect types, and establish similarities, among Free/Libre/Open Source Software (FLOSS) systems, this paper considers three modular characteristics (functions, files and folders) and their evolution: how they are evolving with size, if they are constant across systems, and whether recurring evolutionary patterns are observed. Using these various-grained characteristics,a set of models for the evolution of modularization are extracted from evolving systems, and then used to extract similarities and types from a wide sample of FLOSS projects. This paper provides three contributions: first, it shows that several models are needed to encompass the variety of modularization patterns; second, it provides three types of models (uni-variate, bi-variate and tri-variate) for the evolution of modularization, with significant goodness-of-fit’s. Finally, it shows that two of these patterns alone can interpolate the modular characteristics of the vast majority of a random choice of FLOSS projects.

Easier Said than Done: An Empirical Investigation of Software Design and Quality in Open Source Software Development - Conley, Caryn A.; Lee Sproull (2009 42nd Hawaii International Conference on System Sciences (HICSS 2009), 2009)
We empirically examine the relationship between software design modularity and software quality in open source software (OSS) development projects. Conventional wisdom suggests that degree of software modularity affects software quality. An analysis of 203 software releases in 46 OSS projects hosted on SourceForge.net lends support for a more complex relationship between software modularity and software quality than conventional wisdom suggests. We find that software modularity is associated with reduced software complexity, an increased number of static software bugs, and a mixed relationship with the percentage of bugs closed. We do not find empirical evidence supporting any relationship between modularity and other measures of customer satisfaction. In addition to empirically testing the relationship between modularity and quality, we introduce new measures of software modularity and software quality. Implications are developed for the theory of modularity and the practice of software development.
Keywords: modularity; quality; source code; sourceforge

An Empirical Study of the Reuse of Software Licensed under the GNU General Public License - German, Daniel; González-Barahona, Jesús (OSS2009: Open Source Ecosystems: Diverse Communities Interacting (IFIP 2.13), 2009)
Software licensing is a complex issue in free and open source software (FOSS), specially when it involves the redistribution of derived works. The creation of derivative works created from components with different FOSS licenses poses complex challenges, particularly when one of the components is licensed under the terms of one of the versions of the GNU General Public License (GPL). This paper describes an empirical study of the manner in which GPLed licensed software is combined with components under different FOSS licenses. We have discovered that FOSS software developers have found interesting methods to create derivative works with GPLed software that legally circumvent the apparent restrictions of the GPL. In this paper we document these methods and show that FOSS licenses interact in complex and unexpected ways. In most of these cases the goal of the developers (both licensors and licensees) is to further increase the commons of FOSS.

Envisioning National and International Research on the Multidisciplinary Empirical Science of Free/Open Source Software - Walt Scacchi; Kevin Crowston; Madey, Greg; Squire, Megan (2009)

Estimating Commit Sizes Efficiently - Hofmann, Philipp; Dirk Riehle (OSS2009: Open Source Ecosystems: Diverse Communities Interacting (IFIP 2.13), 2009)
The quantitative analysis of software projects can provide insights that let us better understand open source and other software development projects. An important variable used in the analysis of software projects is the amount of work being contributed, the commit size. Unfortunately, post-facto, the commit size can only be estimated, not measured. This paper presents several algorithms for estimating the commit size. Our performance evaluation shows that simple, straightforward heuristics are superior to the more complex text-analysis-based algorithms. Not only are the heuristics significantly faster to compute, they also deliver more accurate results when estimating commit sizes. Based on this experience, we design and present an algorithm that improves on the heuristics, can be computed equally fast, and is more accurate than any of the prior approaches.

Evaluating Longitudinal Success of Open Source Software Projects: A Social Network Perspective - Jing Wu; Khim Yong Goh (2009 42nd Hawaii International Conference on System Sciences (HICSS 2009), 2009)
To date, numerous open source projects are hosted on many online repositories. While some of these projects are active and thriving, some projects are either languishing or showing no development activities at all. This phenomenon thus begs the important question of what are the influential factors that affect the success of open source projects. In a quest to deepen our understanding of the evolution of open source projects, this research aims to analyze the success of open source projects by using the theoretical lens of social network analysis. Based on extensive analyses of data collected from online repositories, we study the impact of the communication patterns of software development teams on the demand and supply outcomes of these projects, while accounting for project-specific characteristics. Using panel data analysis of data over 13 months, we find significant impacts of communication patterns on project outcomes over the long term.
Keywords: bug tracking system; communication; project success; social network analysis; sourceforge

Evaluating process quality in GNOME based on change request data - Schackmann, Holger; Lichter, Horst (2009 6th IEEE International Working Conference on Mining Software Repositories (MSR)2009 6th IEEE International Working Conference on Mining Software Repositories, 2009)
The lifecycle of defects reports and enhancement requests collected in the Bugzilla database of the GNOME project provides valuable information on the evolution of the change request process and for the assessment of process quality in the GNOME sub projects. We present a quality model for the analysis of quality characteristics that is based on evaluating metrics on the Bugzilla database, and illustrate it with a comparative evaluation for 25 of the largest products within GNOME.
Keywords: bugzilla; bugzillametrics.org; change analysis; change history; gnome; msr challenge; qmetric

Evolution of the core team of developers in libre software projects - Gregorio Robles; Jesus M. Gonzalez-Barahona; Herraiz, Israel (2009 6th IEEE International Working Conference on Mining Software Repositories (MSR)2009 6th IEEE International Working Conference on Mining Software Repositories, 2009)
In many libre (free, open source) software projects, most of the development is performed by a relatively small number of persons, the "core team". The stability and permanence of this group of most active developers is of great importance for the evolution and sustainability of the project. In this position paper we propose a quantitative methodology to study the evolution of core teams by analyzing information from source code management repositories. The most active developers in different periods are identified, and their activity is calculated over time, looking for core team evolution patterns.
Keywords: core; cvs; cvsanaly; developers; evolution; gimp; scm

An Examination of the Use of Open Source Software Processes as a Global Software Development Solution for Commercial Software Engineering - Gaughan, Gary; Fitzgerald, Brian; Maha Shaikh (2009 35th Euromicro Conference on Software Engineering and Advanced Applications, 2009)
This paper outlines the phenomenon of Inner Source software development and places it in the context of existing open source literature. Our study includes an analysis of multiple case studies of Inner Source in use in large scale global software development companies. The lessons learned from these case studies help us to contrast traditional open source principles with Inner Source principles, and we then gather these lessons, to create our preliminary framework, in order to make sense of when and how firms can adopt Inner Source. Our framework helps to make sense of the practical issues of adopting and managing Inner Source. We have highlighted the emerging trends in the Inner Source phenomenon and surrounding areas. Awareness of this may be of great benefit to researchers in the area and industrial practitioners.

An Exploratory Study on the Two New Trends in Open Source Software: End-Users and Service - Namjoo Choi; Chengular-Smith, I. (2009 42nd Hawaii International Conference on System Sciences (HICSS 2009), 2009)
Many have been envisaging the emergence of Open Source Software (OSS) for general end-users and the enhancements in providing services and support, as the most critical factors for OSS success, and at the same time, the most critical issues which are holding back the OSS movement. While these two distinct waves in OSS evolution have become more observable, researchers have not yet explored the characteristics of these two distinct new waves. The current study found evidence for these two waves and further explored the two waves by empirically examining two hundred projects hosted in Sourceforge.net. We compared the characteristics of OSS projects that are intended for two disparate audiences: developers and end-users and found that projects for end-users supported more languages but also had more restrictive licenses as compared to projects for developers.
Keywords: developers; intended audiences; sourceforge

Facts or Friends? Distinguishing Informational and Conversational Questions in Social QnA Sites (forthcoming) - Harper, F. Maxwell; Moy, D.; Konstan, J.A. (ACM SIGCHI Conference on Human Factors in Computing Systems, 2009)

First International Workshop on Building Sustainable Open Source Communities (OSCOMM 2009) - Hammouda, Imed; Aaltonen, Timo; Capiluppi, Andrea (OSS2009: Open Source Ecosystems: Diverse Communities Interacting (IFIP 2.13), 2009)
The First International Workshop on Building Sustainable Open Source Communities aims at building a community of researchers and practitioners to share experiences and discuss challenges involved in building and maintaining open source communities.

Flat for the few, steep for the many: Structural cohesion as a measure of hierarchy in FLOSS communities - Guido Conaldi (4th Workshop on Public Data about Software Development (WoPDaSD 2009), 2009)
A discrepancy exists between the emphasis posed by practitioners on decentralized and non-hierarchical communication in Free/Libre Open Source Software (FLOSS) communities and empirical evidence of their hierarchical structure. In order to explain this apparent paradox it is here hypothesized that in FLOSS communities local sub-groups exist and are less hierarchical, more decentralized than the whole social network to which they belong. A measure of structural cohesion based on network node connectivity is proposed as an effective method to test whether FLOSS communication networks can be decomposed in nested hierarchies of progressively less centralized sub-groups. Preliminary results from a case study that are consistent with the hypothesis are presented and discussed.
Keywords: case study; email; email archives; epiphany; gnome; mailing list; social network analysis

FLOSS UX Design: An Analysis of User Experience Design in Firefox and OpenOffice.org - Bach, Paula; Carroll, John (OSS2009: Open Source Ecosystems: Diverse Communities Interacting (IFIP 2.13), 2009)
We describe two cases of open user experience (UX) design using the Firefox web browser and OpenOffice.org office suite as case studies. We analyze the social complexity of integrating UX practices into the two open source projects using activity awareness, a framework for understanding team performance in collective endeavors of significant scope, duration, and complexity. The facets of activity awareness are common ground, community of practice, social capital, and human development. We found that differences between the communities include different strategies for community building, UX status in the community, type of open UX design, and different ways to share information.

A Framework for Understanding the Open Source Revolution - Elpern, Jeff; Dascalu, Sergiu (International Journal of Open Source Software and Processes, 2009)
Traditional software engineering methodologies have mostly evolved from the environment of proprietary, large-scale software systems. Here, software design principles operate within a hierarchical decision-making context. Development of banking, enterprise resource and complex weapons systems all fit this paradigm. However, another paradigm for developing software-intensive systems has emerged, the paradigm of open source software. Although from a traditional perspective open source projects might look like chaos, their real-world results have been spectacular. This chapter presents open source software development as a fundamentally new paradigm driven by economics and facilitated by new processes. The new paradigm's revolutionary aspects are explored, a framework for describing the massive impact brought about by the new paradigm is proposed, and directions of future research are outlined. The proposed framework's goals are to help the understanding of the open source paradigm as a new economic revolution and stimulate research in designing open source software.

From work to word: How do software developers describe their work? - Maalej, Walid; Happel, Hans-Jorg (2009 6th IEEE International Working Conference on Mining Software Repositories (MSR)2009 6th IEEE International Working Conference on Mining Software Repositories, 2009)
Developers take notes about their work sessions, either to remember the work status and share it with collaborators, or because employers explicitly require this for project management matters. We report on an exploratory study which aims at understanding how software developers describe their work. We analyzed more than 750,000 work descriptions of about 2,000 professionals taken over 8 years in three settings. We observed several similarities in the content and time meta-data of work descriptions. Most frequent terms, such as top-30 performed activities, are used consistently. Particular templates such as ldquoACTION concerning ARTIFACT because of CAUSErdquo occur frequently. Developers described sessions that last 30-120 min. 4-16 times a day. Maintaining diaries seems to consume between 3-6% of the total work time, and in 10% of the sessions, developers did not describe their work in sufficient detail. We argue that our results make the first step towards automatically generating work diaries for software developers.
Keywords: apache; developers; diaries; eureka; mycomp; scm; work management system

Group Maintenance Behaviors of Core and Peripherial Members of Free/Libre Open Source Software Teams - Scialdone, Michael; Li, Na; Robert Heckman; Kevin Crowston (OSS2009: Open Source Ecosystems: Diverse Communities Interacting (IFIP 2.13), 2009)
Group Maintenance is pro-social, discretionary, and relation-building behavior that occurs between members of groups in order to maintain reciprocal trust and cooperation. This paper considers how Free/libre Open Source Software (FLOSS) teams demonstrate such behaviors within the context of e-mail, as this is the primary medium through which such teams communicate. We compare group maintenance behaviors between both core and peripheral members of these groups, as well as behaviors between a group that remains producing software today and one which has since dissolved. Our findings indicate that negative politeness tactics (those which show respect for the autonomy of others) may be the most instrumental group maintenance behaviors that contribute to a FLOSS group’s ability to survive and continue software production.

Heartbeat: Measuring Active User Base and Potential User Interest in FLOSS Projects - Andrea Wiggins; Howison, James; Kevin Crowston (OSS2009: Open Source Ecosystems: Diverse Communities Interacting (IFIP 2.13), 2009)
This paper presents a novel method and algorithm to measure the size of an open source project’s user base and the level of potential user interest that it generates. Previously unavailable download data at a daily resolution confirms hypothesized patterns related to release cycles. In short, regular users rapidly download the software after a new release giving a way to measure the active user base. In contrast, potential new users download the application independently of the release cycle, and the daily download figures tend to plateau at this rate when a release has not been made for some time. An algorithm for estimating these measures from download time series is demonstrated and the measures are examined over time in two open source projects.

How Open Source Can Still Save the World - Behlendorf, Brian (OSS2009: Open Source Ecosystems: Diverse Communities Interacting (IFIP 2.13), 2009)
Many of the worlds’ major problems - economic distress, natural disaster responses, broken health care systems, education crises, and more - are not fundamentally information technology issues. However, in every case mentioned and more, there exist opportunities for Open Source software to uniquely change the way we can address these problems. At times this is about addressing a need for which no sufficient commercial market exists. For others, it is in the way Open Source licenses free the recipient from obligations to the creators, creating a relationship of mutual empowerment rather than one of dependency. For yet others, it is in the way the open collaborative processes that form around Open Source software provide a neutral ground for otherwise competitive parties to find a greatest common set of mutual needs to address together rather than in parallel. Several examples of such software exist today and are gaining traction. Governments, NGOs, and businesses are beginning to recognize the potential and are organizing to meet it. How far can this be taken?

Identifying exogenous drivers and evolutionary stages in FLOSS projects - Karl Beecher; Capiluppi, Andrea; Boldyreff, Cornelia (Journal of Systems and Software, 2009)
The success of a Free/Libre/Open Source Software (FLOSS) project has been evaluated in the past through the number of commits made to its configuration management system, number of developers and number of users. Most studies, based on a popular FLOSS repository (SourceForge), have concluded that the vast majority of projects are failures. This study's empirical results confirm and expand conclusions from an earlier and more limited work. Not only do projects from different repositories display different process and product characteristics, but a more general pattern can be observed. Projects may be considered as early inceptors in highly visible repositories, or as established projects within desktop-wide projects, or finally as structured parts of FLOSS distributions. These three possibilities are formalized into a framework of transitions between repositories. The framework developed here provides a wider context in which results from FLOSS repository mining can be more effectively presented. Researchers can draw different conclusions based on the overall characteristics studied about an Open Source software project's potential for success, depending on the repository that they mine. These results also provide guidance to OSS developers when choosing where to host their project and how to distribute it to maximize its evolutionary success.
Keywords: developers; forge; forges; repositories; repository; scm; software repositories; sourceforge; success; users

Identifying How Determinants Impact Security-Based Open Source Software Project Success Using Rule Induction - Wray, Barry; Mathieu, Richard; Teets, J. (International Journal of Electronic Marketing and Retailing, 2009)

The Importance of External Support in the Adoption of Open Source Server Software - Ven, Kris; Verelst, Jan (OSS2009: Open Source Ecosystems: Diverse Communities Interacting (IFIP 2.13), 2009)
IT managers seem to be hesitant to adopt OSS in the absence of professional support. Previous qualitative studies have indeed suggested that the availability of external support is important for the adoption of OSS. Therefore, we feel it is interesting to gain more insight into the role of external support in the adoption process. To this end, we performed a web survey involving 95 Belgian organizations. Our data suggests a balanced picture. As expected, our results show that the majority of organizations in our sample rely on commercial support such as vendor or third party support. Even organizations that have deployed OSS to a large extent—and that are therefore likely to have some experience and familiarity with OSS—rely on commercial support. Nevertheless, a considerable proportion of organizations indicated not to rely on commercial support, which suggests that internal expertise can be sufficient for successful adoption. Finally, and most surprisingly, we have found that the OSS community is used by a large proportion of organizations. This indicates that the OSS community is a valuable source of external support for organizations. Nevertheless, it appears that it is primarily used by organizations with a rather strong background in IT.

Innovation, Imitation and Open Source - Pollock, Rufus (International Journal of Open Source Software and Processes, 2009)
An extensive empirical literature indicates that, even without formal intellectual property rights, innovators enjoy a variety of first-mover advantages and that ‘imitation’ is itself a costly activity. There is also accumulating evidence that an ‘open’ approach to knowledge production can deliver substantial efficiency advantages. This article introduces a formal framework incorporating all of these factors. We examine the relative performance of an ‘open’ versus a ‘closed’ (proprietary) regime, and explicitly characterize the circumstances in which an open approach, despite its effect on facilitating imitation, results in a higher level of innovation.

Integrating HCI Specialists into Open Source Software Development Projects - Hedberg, Henrik; Iivari, Netta (OSS2009: Open Source Ecosystems: Diverse Communities Interacting (IFIP 2.13), 2009)
Typical open source software (OSS) development projects are organized around technically talented developers, whose communication is based on technical aspects and source code. Decision-making power is gained through proven competence and activity in the project, and non-technical end-user opinions are too many times neglected. In addition, also human-computer interaction (HCI) specialists have encountered difficulties in trying to participate in OSS projects, because there seems to be no clear authority and responsibility for them. In this paper, based on HCI and OSS literature, we introduce an extended OSS development project organization model that adds a new level of communication and roles for attending human aspects of software. The proposed model makes the existence of HCI specialists visible in the projects, and promotes interaction between developers and the HCI specialists in the course of a project.

Integrating Projects from Multiple Open Source Code Forges - Squire, Megan (International Journal of Open Source Software and Processes, 2009)
Much of the data about free, libre, and open source (FLOSS) software development comes from studies of code forges or code repositories used for managing projects. This paper presents a method for integrating data about open source projects by way of matching projects (entities) across multiple code forges. After a review of the relevant literature, a few of the methods are chosen and applied to the FLOSS domain, including a comparison of some simple scoring systems for pairwise project matches. Finally, the paper describes limitations of this approach and recommendations for future work.
Keywords: data integration; forges

Intellectual Property Rights Requirements for Heterogeneously Licensed Systems - Alspaugh, Thomas; Hazeline U. Asuncion; Walt Scacchi (17th Internnational Conference on Requirements Engineering (RE09), 2009)

A Joint Workshop of QACOS and OSSPL - Ali Babar, Muhammad; Lundell, Björn; van der Linden, Frank (OSS2009: Open Source Ecosystems: Diverse Communities Interacting (IFIP 2.13), 2009)
The OSS movement, which originated from a pragmatic need to share code among individuals, has grown to become a major force behind inter-organizational reuse of platforms, components and code. The use of open source software to build single or family of systems (i.e., product line development) appears to be a profitable way to quality software products. On the other hand, because of the diverse use of open source software, product line development is an attractive way of working in open source communities. The configuration mechanisms used in open source communities may be applicable within software product lines variability management. In addition, product line organizations are usually involved in distributed development, which works very efficiently within open source communities, leading to high quality products. However, at present, there is limited interaction between the open source and product line development communities.

A Jury of Your Peers: Quality, Experience and Ownership in Wikipedia - Halfaker, A.; Kittur, N.; Kraut, R.; Riedl, J. (The International Symposium on Wiki's and Open Collaboration, 2009)
Keywords: experience,; ownership,; peer; peer,; quality; review,; wikipedia,; wikiwork,

Language entropy: A metric for characterization of author programming language distribution - Krein, Jonathan L.; MacLean, Alexander C.; Delorey, Daniel P.; Knutson, Charles D.; Eggett, Dennis L. (4th Workshop on Public Data about Software Development (WoPDaSD 2009), 2009)
Programmers are often required to develop in multiple languages. In an eﬀort to study the eﬀects of programming language fragmentation on productivity—and ultimately on a programmer’s problem solving abilities—we propose a metric, language entropy, for characterizing the distribution of an individual’s development eﬀorts across multiple programming languages. To evaluate this metric, we present an observational study examining all project contributions (through August 2006) of a random sample of 500 SourceForge developers. Using a random coeﬃcients model, we found a statistically signiﬁcant correlation (alpha level of 0.05) between language entropy and the size of monthly pro ject contributions (measured in lines of code added). Our results indicate that language entropy is a good candidate for characterizing author programing language distribution.
Keywords: contributions; developers; language entropy; lines of code; loc; multiple languages; programming languages; sourceforge

Learning from defect removals - Ayewah, Nathaniel; Pugh, William (2009 6th IEEE International Working Conference on Mining Software Repositories (MSR)2009 6th IEEE International Working Conference on Mining Software Repositories, 2009)
Recent research has tried to identify changes in source code repositories that fix bugs by linking these changes to reports in issue tracking systems. These changes have been traced back to the point in time when they were previously modified as a way of identifying bug introducing changes. But we observe that not all changes linked to bug tracking systems are fixing bugs; some are enhancing the code. Furthermore, not all fixes are applied at the point in the code where the bug was originally introduced. We flesh out these observations with a manual review of several software projects, and use this opportunity to see how many defects are in the scope of static analysis tools.
Keywords: bug fixing; bugzilla; change management; cherry; cvs; eclipse; groovy; launching; source code; svn; text editor

Learning to Recognize Valuable Tags - Sen, S.; Vig, J.; Riedl, J. (International Conference on Intelligent User Interfaces, 2009)

Libre Software in Spanish Public Administrations - Ortega, Felipe; Lafuente, Isabel; Gato, Jose; González-Barahona, Jesús (OSS2009: Open Source Ecosystems: Diverse Communities Interacting (IFIP 2.13), 2009)
Libre software started to be used in Public Administrations in Spain during the 1990s, in some isolated but interesting experiences.During the early 2000s, and specially in some regional governments, libre software started to be considered as an integral part of ITrelated policies. In 2007, it was evident that many experiences related to libre software were running in Public Administrations with different levels of success. However, no study had looked into the details of these experiences, and no comprehensive analysis had been performed to better understand the different factors that affect them.

Making New Friends, but Keep the Old - Recommending People on Social Networking Sites (forthcoming) - Chen, J; Geyer, W.; Dugan, C.; Muller, M.; Guy, I. (ACM SIGCHI Conference on Human Factors in Computing Systems, 2009)

MapReduce as a general framework to support research in Mining Software Repositories (MSR) - Weiyi Shang; Zhen Ming Jiang; Adams, Bram; Hassan, Ahmed E. (2009 6th IEEE International Working Conference on Mining Software Repositories (MSR)2009 6th IEEE International Working Conference on Mining Software Repositories, 2009)
Researchers continue to demonstrate the benefits of Mining Software Repositories (MSR) for supporting software development and research activities. However, as the mining process is time and resource intensive, they often create their own distributed platforms and use various optimizations to speed up and scale up their analysis. These platforms are project-specific, hard to reuse, and offer minimal debugging and deployment support. In this paper, we propose the use of MapReduce, a distributed computing platform, to support research in MSR. As a proof-of-concept, we migrate J-REX, an optimized evolutionary code extractor, to run on Hadoop, an open source implementation of MapReduce. Through a case study on the source control repositories of the Eclipse, BIRT and Datatools projects, we demonstrate that the migration effort to MapReduce is minimal and that the benefits are significant, as running time of the migrated J-REX is only 30% to 50% of the original J-REX's. This paper documents our experience with the migration, and highlights the benefits and challenges of the MapReduce framework in the MSR community.
Keywords: hadoop; mapreduce

On the Maturity of Open Source BPM Systems - Wohed, P.; ter Hofstede, A.H.M.; Russell, N.; Andersson, B.; van der Aalst, W.M.P (BP Trends, 2009)
Two major trends in the area of information systems development are the growing interest for Workflow and Busi- ness Process Management (BPM) systems and the increasing acceptance and spread of open source software. This development raises the following questions: 1. What are the prominent representatives of current open source Workflow and BPM systems? 2. What is the maturity level of these systems? Seeking answers to these questions we have performed a study. First an overview of the existing open source systems was made and three systems: jBPM, OpenWFE, and Enhydra Shark, selected for further analysis. Then a detailed analysis on the selected systems was performed. The results from this analysis were documented and the developers invited to comment. Based on the feedback from the developers the results were revisited and the study finalized [5]. In this article we summarise the study and reflect on the area of open source BPM systems.

Measuring the performance of open source development communities: The QualOSS approach - Soto, Martin; Izquierdo-Cortázar, Daniel; Ciolkowski, Marcus (MetriKon 2009 - Praxis der Software-Messung : Tagungsband des DASMA Software Metrik Kongresses, 2009)
Free and Open Source Software (F/OSS) has an increasing importance for the software industry. Similar to traditional (closed) software acquisition, F/OSS acquisition requires an assessment of whether its quality is sufficient for the intended purpose, and of whether the chances of being maintained and supported in the future, as well as of keeping certain quality standards over time, are sufficiently high. The first one of these aspects is strictly product related, and can be assessed using techniques that are not specific to F/OSS. The last two aspects, however, are related to the community developing the software, and require novel approaches to be evaluated properly. In this paper, we present an approach toward a comprehensive measurement framework for F/OSS projects, developed in the EU project QualOSS. Although this approach takes into account product quality as well as process maturity and sustainability of the underlying F/OSS community, we concentrate here on its community-related aspects. After describing our quality model and assessment techniques in some detail, we close with a description of our ongoing evaluation effort and a discussion of lessons learned.

On mining data across software repositories - Anbalagan, Prasanth; Vouk, Mladen (2009 6th IEEE International Working Conference on Mining Software Repositories (MSR)2009 6th IEEE International Working Conference on Mining Software Repositories, 2009)
Software repositories provide abundance of valuable information about open source projects. With the increase in the size of the data maintained by the repositories, automated extraction of such data from individual repositories, as well as of linked information across repositories, has become a necessity. In this paper we describe a framework that uses web scraping to automatically mine repositories and link information across repositories. We discuss two implementations of the framework. In the first implementation, we automatically identify and collect security problem reports from project repositories that deploy the Bugzilla bug tracker using related vulnerability information from the National Vulnerability Database. In the second, we collect security problem reports for projects that deploy the Launchpad bug tracker along with related vulnerability information from the National Vulnerability Database. We have evaluated our tool on various releases of Fedora, Ubuntu, Suse, RedHat, and Firefox projects. The percentage of security bugs identified using our tool is consistent with that reported by other researchers.
Keywords: bug reports; bugzilla; Fedora; Firefox; htmlscraper; integration; launchpad; national vulnerability database; RedHat; Suse; tracker; Ubuntu

Mining Programming Language Vocabularies from Source Code - Delorey, Daniel P.; Knutson, Charles D.; Davies, Mark (21st Annual Psychology of Programming Interest Group Conference, 2009)
We can learn much from the artifacts produced as the by-products of software devel- opment and stored in software repositories. Of all such potential data sources, one of the most important from the perspective of program comprehension is the source code itself. While other data sources give insight into what developers intend a program to do, the source code is the most accurate human-accessible description of what it will do. However, the ability of an individual developer to comprehend a particular source file depends directly on his or her familiarity with the specific features of the programming language being used in the file. This is not unlike the difficulties second-language learners may encounter when attempting to read a text written in a new language. We propose that by applying the techniques used by corpus linguists in the study of natural language texts to a corpus of programming language texts (i.e., source code repositories), we can gain new insights into the communication medium that is programming language. In this paper we lay the foundation for applying corpus linguistic methods to programming language by 1) defining the term “word” for programming language, 2) developing data collection tools and a data storage schema for the Java programming language, and 3) presenting an initial analysis of an example linguistic corpus based on version 1.5 of the Java Developers Kit.

Mining search topics from a code search engine usage log - Bajracharya, Sushil; Lopes, Cristina (2009 6th IEEE International Working Conference on Mining Software Repositories (MSR)2009 6th IEEE International Working Conference on Mining Software Repositories, 2009)
We present a topic modeling analysis of a year long usage log of Koders, one of the major commercial code search engines. This analysis contributes to the understanding of what users of code search engines are looking for. Observations on the prevalence of these topics among the users, and on how search and download activities vary across topics, leads to the conclusion that users who find code search engines usable are those who already know to a high level of specificity what to look for. This paper presents a general categorization of these topics that provides insights on the different ways code search engine users express their queries. The findings support the conclusion that existing code search engines provide only a subset of the various information needs of the users when compared to the categories of queries they look at.
Keywords: analysis; black duck; koders; log; logfile; search; source code

Mining source code to automatically split identifiers for software analysis - Enslen, Eric; Hill, Emily; Pollock, Lori; Vijay-Shanker, K. (2009 6th IEEE International Working Conference on Mining Software Repositories (MSR)2009 6th IEEE International Working Conference on Mining Software Repositories, 2009)
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

Mining the coherence of GNOME bug reports with statistical topic models - Linstead, Erik; Baldi, Pierre (2009 6th IEEE International Working Conference on Mining Software Repositories (MSR)2009 6th IEEE International Working Conference on Mining Software Repositories, 2009)
We adapt latent Dirichlet allocation to the problem of mining bug reports in order to define a new information-theoretic measure of coherence. We then apply our technique to a snapshot of the GNOME Bugzilla database consisting of 431,863 bug reports for multiple software projects. In addition to providing an unsupervised means for modeling report content, our results indicate substantial promise in applying statistical text mining algorithms for estimating bug report quality. Complete results are available from our supplementary materials Web site at http://sourcerer.ics.uci.edu/msr2009/gnome_coherence.html.
Keywords: bug reports; bugzilla; gnome; msr challenge; quality; sourcerer

Monetary donations to an open source software platform - Sandeep Krishnamurthy; Tripathi, Arvind K. (Research Policy, 2009)
Online open source software platforms, such as Sourceforge.net, play a vital role in creating an ecosystem that enables the creation and growth of open source projects. However, there is little research exploring the interactions between open source stakeholders and the platform. We believe that the sustainability of the platform crucially depends on financial incentives. While platforms can obtain these incentives through multiple means, in this paper we focus on one form of financial incentives—voluntary monetary donations by open source community members. We report findings from two empirical studies that examine factors that impact donations. Study 1 investigates the factors that cause some community members to donate and not others. We find that the decision to donate is impacted by relational commitment with open source software platform, donation to projects and accepting donations from others. Study 2 examines what drives the level of donation. We find that the length of association with the platform and relational commitment affects donation levels.
Keywords: Collective action; Donation; Identification; incentives; metadata; MOTIVATION; Open source software platform; projects; Reciprocity; Relational commitment; sourceforge

Motivation of Open Source Developers - Allyn, Mark R.; Misra, Ram B. (International Journal of Open Source Software and Processes, 2009)
The motivational drivers of open source software developers have been researched by various investigators since about 2000. This work shows that developers are motivated by different extrinsic and intrinsic drivers, among them community aspirations, reciprocity and fairness, creative impulses, and monetary and career ambitions. There has been some work done in studying whether the profile of developer motivations is constant across open source projects or is sensitive to project organizational design. Among the many factors that could influence the mix of motives of OS developers is the license under which the work is performed. Licenses range in openness between those such as the GNU GPL that severely restrict the freedom of developers to mingle their OS code with proprietary code to those such as BSD licenses which allow programmers much greater latitude in integrating open source code with proprietary code. In addition to formal rules, meritocracies emerge to reward effort and performance, and also to direct, coordinate, and control other participants. The authors discuss these variables and how they may be related to motivations.

Multiple Social Networks Analysis of FLOSS Projects using Sargas - de Sousa, S.F.; Balieiro, M.A.; dos R. Costa, J.M.; de Souza, C.R.B. (2009 42nd Hawaii International Conference on System Sciences (HICSS 2009), 2009)
Due to their characteristics and claimed advantages, several researchers have been investigating free and open-source projects. Different aspects are being studied: for instance, what motivates developers to join FLOSS projects, the tools, processes and practices used in FLOSS projects, the evolution of FLOSS communities among other things. Researchers have studied collaboration and coordination of open source software developers using an approach known as social network analysis and have gained important insights about these projects. Most researchers, however, have not focused on the integrated study of these networks and, accordingly, in their interrelationships. This paper describes an approach and tool to combine multiple social networks to study the evolution of open-source projects. Our tool, named Sargas, allows comparison and visualization of different social networks at the same time. Initial results of our analysis can be used to extend the "onion-model" of open source participation.
Keywords: case study; multiple social networks; ossnetwork; pmd; social network analysis; transflow

NESSI OSS Workshop (OSS2009: Open Source Ecosystems: Diverse Communities Interacting (IFIP 2.13), 2009)
The NESSI Technology Platform aims to provide a unified view for European research and development in Services Architectures and Software Infrastructures that will define technologies for new, open, industrial solutions and societal applications that enhance the safety, security and well-being of citizens.

Open Source and Commercial Software Platforms - Darmon, Eric; Torre, Dominique (International Journal of Open Source Software and Processes, 2009)
In this article, we consider the dynamics and competition between two software platforms (Open Source and proprietary software). Potential user-developers can adopt one of the two platforms in order to develop and sell new applications based on the platform. We consider the static issue first and then use a simple dynamic system where the dynamics comes from the development efforts (spillovers) made on each platforms. In this context, we first identify the conditions for the two platforms to coexist in the long run. From this baseline, we then consider different strategies for the editor. A first strategy is for the editor to “show the code” of its software, so as to develop more compatible products. A second strategy is to strategically monitor the compatibility degree between the proprietary and OS platform. In both cases, we analyze whether a mixed industry may be sustainable in the long run.

Open Source Is Changing the Way Work Gets Done - Peters, Stormy (OSS2009: Open Source Ecosystems: Diverse Communities Interacting (IFIP 2.13), 2009)
Open source software is changing not only the way the software industry works, but also the way work gets done. In the open source software model, individuals and companies collaborate together to produce software. They learn new ways of getting work done that are based on meritocracy and little management. In addition, they learn ways of communication that work well across large groups and virtual environments. These new ways of communicating and getting work done are changing the nature of work across all industries, not just the software industry, industries like mobile technology providers and medical equipment. Come learn how the open source software model is changing the way individuals and companies work and collaborate.

Open Source Software Adoption: Anatomy of Success and Failure - Fitzgerald, Brian (International Journal of Open Source Software and Processes, 2009)
Current estimates suggest widespread adoption of open source software (OSS) in organizations worldwide. However, the problematic nature of OSS adoption is readily evidenced in the fairly frequent reports of problems, unforeseen hold-ups, and outright abandonment of OSS implementation over time. Hibernia Hospital, an Irish public sector organization, have embarked on the adoption of a range of OSS applications over several years, some of which have been successfully deployed and remain in live use within the organisation, whereas others, despite achieving high levels of assimilation over a number of years, have not been ultimately retained in live use in the organization. Using a longitudinal case study, we discuss in depth the deployment process for two OSS applications – the desktop application suite whose deployment was unsuccessful ultimately, and the email application which was successfully deployed. To our knowledge, this is the first such in-depth study into successful and unsuccessful OSS implementation.
Keywords: adoption; project failure; project success

Open Source Software Governance Serving Technological Agility - Le Texier, Thomas; Versailles, David W. (International Journal of Open Source Software and Processes, 2009)
The development of open source software is currently arousing increasing interest in the IT world. This research inquires some specific paths enlarging the traditional view over open source software in inquiring the US Department of Defense (DoD) and the dynamics associated its front- and back-office activities. We explain how distinguishing basic administration from operational constraints and weapon R&D dynamics introduces specific governance concerns among public and private stakeholders. By no longer defining open source solutions as mere goods, but as services characterized by a flow of knowledge, we particularly highlight new emerging strategies of technological acquisition. Our analysis leads to revise the traditional role focusing mainly on cost issues and introduces open source software with distinctive properties serving the management of innovation and technological agility at the level of complex systems, exemplified here with the constraints associated to weapon systems and the Network centric warfare doctrine

Opening Industrial Software: Planting an Onion - Sirkkala, Petri; Aaltonen, Timo; Hammouda, Imed (OSS2009: Open Source Ecosystems: Diverse Communities Interacting (IFIP 2.13), 2009)
This paper studies the problem of building open source communities for industrial software that was originally developed as closed source. We present a conceptual framework for planning the early stages of the release process highlighting the main stakeholders and concerns involved. The framework is illustrated by means of three industrial software platforms reporting first experiences of the community building process. In order to measure the effectiveness of the approach, the use of a quantitative and qualitative evaluation framework is advocated.

Openness to Standard Document Formats in Swedish Public Sector Organisations - Lundell, Björn; Lings, Brian (OSS2009: Open Source Ecosystems: Diverse Communities Interacting (IFIP 2.13), 2009)
There is a strong movement in Europe to promote products that support open, well-documented standards. Directives and proposals at European and national levels have been developed in this area. There is in particular an increasing recognition of the need for governmental organisations to support and promote standard document formats. This vision can stand in stark contrast with the reality of those document formats which can currently be accepted and produced by those organisations. In this paper we address the question: to what extent can and do Swedish governmental organisations respond appropriately when presented with a document in a format that conforms to an open standard? We find that a small minority of organisations can actually do so, whereas all are willing and able to accept documents in a proprietary format. The study also highlights a lack of transparency in organisations regarding formats which should be accepted and used for communication with the general public.

Panel: Governance in Open Source Projects and Communities - Bolici, Francesco; de Laat, Paul; Ljungberg, Jan; Pontiggia, Andrea; Rossi Lamastra, Cristina (OSS2009: Open Source Ecosystems: Diverse Communities Interacting (IFIP 2.13), 2009)
“Although considerable research has been devoted to the growth and expansion of open source communities and the comparison between the efficiency of corporate structures and community structures in the field of software development, rather less attention has been paid to their governance structures (control, monitoring, supervision)” (Lattemann and Stieglitz 2005).

Panel: Open Source in the Public Sector - Lundell, Björn; Amundsen, Morten; Ghosh, Rishab; Hardy, Jean-Luc; Sjöswärd, Per-Ola (OSS2009: Open Source Ecosystems: Diverse Communities Interacting (IFIP 2.13), 2009)
Open Source Software (OSS) is becoming mainstream, and it is perhaps not surprising that public sector organisations seek to explore the potential of OSS in financially difficult times. Today, OSS has become an issue of strategic importance for many public sector organisations. In addition, related to OSS, many organisations and governments are also acknowledging Open Standards as important for addressing various lock-in scenarios.

Participation in online interaction spaces: Design-use mediation in an Open Source Software community - Barcellini, Flore; Détienne, Françoise; Burkhardt, Jean-Marie (International Journal of Industrial Ergonomics, 2009)
This research aims at characterizing emerging roles fostering design-use mediation during the Open Source Software (OSS) design process through the analysis of participation. Studying OSS is of particular interest: (1) to investigate socio-technical settings supporting user participation to the design process, which is considered to be the major strength of OSS design; (2) to gain insights into supporting the changing nature of the software industry, which is becoming more and more distributed and global, and which is thus increasingly making use of OSS design tools and methods. In this research, we characterized effective roles of participants, i.e. participation, on the basis of activities analysis in three online interaction spaces (discussion, documentation and implementation) during a continuous “pushed-by-users” design process of the Python project. Participation is targeted through a methodology articulating: (1) structural analyses (organization of the discussions, regularity and involvement of participants, quotes-based social network) in usage-oriented and development-oriented mailing lists of the projects’ discussion space; (2) actions to the code and documentation made by participants in the implementation and documentation spaces. Besides the importance of the users’ contribution to the process, OSS design is fostered by some key-participants, the cross-participants, who act as boundary spanners between the developers and the users, helping them to go beyond some barriers to participation. These findings can be reinforced developing software to automate the structural analysis of discussions and actions to the code and documentation.
Keywords: Distributed participatory design

Peeling the Onion - Masmoudi, Héla; den Besten, Matthijs; de Loupy, Claude; Jean-Michel Dalle (OSS2009: Open Source Ecosystems: Diverse Communities Interacting (IFIP 2.13), 2009)
According to the now widely accepted “onion-model” of the organization of open source software development, an open source project typically relies on a core of developers that is assisted by a larger periphery of users. But what does the role of the periphery consist of? Raymond’s Linus’s Law which states that “given enough eyeballs all bugs are shallow” suggests at least one important function: the detection of defects. Yet, what are the ways through which core and periphery interact with each other? With the help of text-mining methods, we study the treatment of bugs that affected the Firefox Internet browser as reflected in the discussions and actions recorded in Mozilla’s issue tracking system Bugzilla. We find various patterns in the modes of interactions between core and peripheral members of the community. For instance, core members seem to engage more frequently with the periphery when the latter proposes a solution (a patch). This leads us to conclude that Alan Cox’s dictum “show me the code”, perhaps even more than Linus’s law, seems to be the dominant rule that governs the development of software like Firefox.

Perceptions and Practices of Usability in the Free/Open Source Software (FOSS) Community - Terry, M.; Kay, M.; Lafreniere, B. (David R. Cheriton School of Computer Science, University of Waterloo, 2009)

A platform for software engineering research - Gousios, Georgios; Diomidis Spinellis (2009 6th IEEE International Working Conference on Mining Software Repositories (MSR)2009 6th IEEE International Working Conference on Mining Software Repositories, 2009)
Research in the fields of software quality, maintainability and evolution requires the analysis of large quantities of data, which often originate from open source software projects. Collecting and preprocessing data, calculating metrics, and synthesizing composite results from a large corpus of project artifacts is a tedious and error prone task lacking direct scientific value. The Alitheia Core tool is an extensible platform for software quality analysis that is designed specifically to facilitate software engineering research on large and diverse data sources, by integrating data collection and preprocessing phases with an array of analysis services, and presenting the researcher with an easy to use extension mechanism. Alitheia Core aims to be the basis of an ecosystem of shared tools and research data that will enable researchers to focus on their research questions at hand, rather than spend time on re-implementing analysis tools. In this paper, we present the Alitheia Core platform in detail and demonstrate its usefulness in mining software repositories by guiding the reader through the steps required to execute a simple experiment.
Keywords: alitheia core

The promises and perils of mining git - Christian Bird; Peter C. Rigby; Earl T. Barr; David J. Hamilton; Daniel M. Germán; Premkumar T. Devanbu (Proceedings of the 6th International Working Conference on Mining Software Repositories, MSR 2009, 2009)
We are now witnessing the rapid growth of decentralized source code management (DSCM) systems, in which every developer has her own repository. DSCMs facilitate a style of collaboration in which work output can flow sideways (and privately) between collaborators, rather than always up and down (and publicly) via a central repository. Decentralization comes with both the promise of new data and the peril of its misinterpretation. We focus on git, a very popular DSCM used in high-profile projects. Decentralization, and other features of git, such as automatically recorded contributor attribution, lead to richer content histories, giving rise to new questions such as "How do contributions flow between developers to the official project repository?" However, there are pitfalls. Commits may be reordered, deleted, or edited as they move between repositories. The semantics of terms common to SCMs and DSCMs sometimes differ markedly, potentially creating confusion. For example, a commit is immediately visible to all developers in centralized SCMs, but not in DSCMs. Our goal is to help researchers interested in DSCMs avoid these and other perils when mining and analyzing git data.
Keywords: dscm; git; mining; scm; source code

Providing Commercial Open Source Software: Lessons Learned - Hauge, Øyvind; Ziemer, Sven (OSS2009: Open Source Ecosystems: Diverse Communities Interacting (IFIP 2.13), 2009)
Even though companies like Sun, IBM, MySQL and others have released several commercial Open Source Software (OSS) products, little evidence exist of how to successfully launch such products and establish a living community around them. This paper presents a case study from a small software company succeeding at establishing a business model and a vivid community around their own OSS products. Based on this case study, the paper presents lessons learned which could help other OSS providers.

Putting it All Together: Using Socio-Technical Networks to Predict Failures - Christian Bird; Nachiappan Nagappan; Devanbu, Premkumar; Gall, Harald; Brendan Murphy (Proceedings of the 17th International Symposium on Software Reliability Engineering, 2009)
Studies have shown that social factors in development organizations have a dramatic effect on software quality. Separately, program dependency information has also been used successfully to predict which software components are more fault prone. Interestingly, the influence of these two phenomena have only been studied separately. Intuition and practical experience suggests, however, that task assignment (i.e. who worked on which components and how much) and dependency structure (which components have dependencies on others) together interact to influence the quality of the resulting software. We study the influence of combined socio-technical software networks on the fault-proneness of individual software components within a system. The network properties of a software component in this combined network are able to predict if an entity is failure prone with greater accuracy than prior methods which use dependency or contribution information in isolation. We evaluate our approach in different settings by using it on Windows Vista and across six releases of the Eclipse development environment including using models built from one release to predict failure prone components in the next release. We compare this to previous work. In every case, our method performs as well or better and is able to more accurately identify those software components that have more post-release failures, with precision and recall rates as high as 85%.
Keywords: eclipse; microsoft; social network; vista; windows

Quality Factors and Coding Standards - a Comparison Between Open Source Forges - Capiluppi, Andrea; Boldyreff, Cornelia; Karl Beecher; Paul J. Adams (Electronic Notes in Theoretical Computer Science, 2009)
Enforcing adherence to standards in software development in order to produce high quality software artefacts has long been recognised as best practice in traditional software engineering. In a distributed heterogeneous development environment such those found within the Open Source paradigm, coding standards are informally shared and adhered to by communities of loosely coupled developers. Following these standards could potentially lead to higher quality software. This paper reports on the empirical analysis of two major forges where OSS projects are hosted. The first one, the KDE forge, provides a set of guidelines and coding standards in the form of a coding style that developers may conform to when producing the code source artefacts. The second studied forge, SourceForge, imposes no formal coding standards on developers. A sample of projects from these two forges has been analysed to detect whether the SourceForge sample, where no coding standards are reinforced, has a lower quality than the sample from KDE. Results from this analysis form a complex picture; visually, all the selected metrics show a clear divide between the two forges, but from the statistical standpoint, clear distinctions cannot be drawn amongst these quality related measures in the two forge samples.
Keywords: artefacts; artifacts; coding standards; coding style; complexity; forge; forges; kde; metrics; quality; source code; sourceforge

Quality of Open Source Software: The QualiPSo Trustworthiness Model - del Bianco, Vieri; Lavazza, Luigi; Morasca, Sandro; Taibi, Davide (OSS2009: Open Source Ecosystems: Diverse Communities Interacting (IFIP 2.13), 2009)
Trustworthiness is one of the main issues upon which the decision whether to adopt an Open-Source Software (OSS) product is based. The work described here is part of an activity that has the goals of 1) defining an adequate notion of trustworthiness of software products and artifacts and 2) identifying a number of factors that influence it. Specifically, this paper reports about the identification of the “dimensions” of trustworthiness, i.e., of the high-level qualities that software products and artefacts have to posses in order to be considered trustworthy. These dimensions are described by means of a conceptual model of trustworthiness, which comprises the representation of the factors that affect the user’s perception of trustworthiness, as well as the objective characteristics of the products that contribute to “build” trustworthi-ness. The aforementioned model is equipped with a measurement plan that de-scribes, at the operational level, how to perform the evaluation of the trustwor-thiness of OSS products. The proposed model provides the basis to build quantitative models of the trustworthiness of OSS products and artifacts that are able to explain the relationships between the (objectively observable) characteristics of OSS products and the level of trustworthiness perceived by the users of such products.

The QualOSS open source assessment model measuring the performance of open source communities - Soto, Martin; Ciolkowski, Marcus (2009 3rd International Symposium on Empirical Software Engineering and Measurement (ESEM)2009 3rd International Symposium on Empirical Software Engineering and Measurement, 2009)
Open Source Software (OSS) has an increasing importance for the software industry. Similar to traditional (closed) software acquisition, OSS acquisition requires an assessment of whether its quality is sufficient for the intended purpose, and whether the chances of being maintained and supported in the future, as well as of keeping certain quality standards over time, are sufficiently high. In this paper, we present an approach toward a comprehensive measurement framework for OSS projects, developed in the EU project QualOSS. This approach takes into account product quality as well as process maturity and sustainability of the underlying OSS community.

Reassessing Brooks’ Law for the Free Software Community - Capiluppi, Andrea; Adams, Paul (OSS2009: Open Source Ecosystems: Diverse Communities Interacting (IFIP 2.13), 2009)
Proponents of Free Software have argued that some of the most established software engineering principles do not fully apply when considered in an open, distributed approach. Among these principles, “Brooks’ Law” has been questioned in the Free Software context: large teams of developers, contrary to the law, will not need an increasingly growing number of communication channels. As advocates claim, this is due to the internal haracteristics of the Free Software process: the high modularity of the code helps developers to work on comparted sections, without the need to coordinate with all other contriutors. This paper examines Brooks’ Law in a Free Software context, and it studies the interaction of contributors to a large Free Software project, KDE. The network of interactions is analyzed and a summary term, the “compaction”, is dynamically evaluated to test how the coordination mechanism evolves over time in the project. This paper argues that the claim of advocates holds true, but with limitations: in the KDE project, the few initial developers needed a significant amount of communication. The growth of KDE brought the need to break the number of overall communication channels to a significant extent. Finally, an established amount of 300 developers currently needs the same amount of communication as when the developers were only 10. We interpret this result by arguing that Brooks’ Law holds true among the core developers of any large Free Software project.

Release Mismanagement in Open Source - Wright, Hyrum; Perry, Dewayne (OSS2009: Open Source Ecosystems: Diverse Communities Interacting (IFIP 2.13), 2009)
To a user, unreleased software is nonexistent software, even in open source projects which make the source code readily accessible. Every project requires regular software releases to encourage adoption and attract developers. Different projects approach the task of releasing software in variousways [2], and many experience breakdowns in their release process at some point during their evolution [3]. This poster presents examples of these instances, and how projects are learning from and improving upon them.

Reporting Empirical Research in Open Source Software: The State of Practice - Stol, Klaas-Jan; Ali Babar, Muhammad (OSS2009: Open Source Ecosystems: Diverse Communities Interacting (IFIP 2.13), 2009)
Background: The number of reported empirical studies of Open Source Software (OSS) has continuously been increasing. However, there has been no effort to systematically review the state of the practice of reporting empirical studies of OSS with respect to the recommended standards of performing and reporting empirical studies in software engineering. It is important to understand, how to report empirical studies of OSS in order to make them useful for practitioners and researchers. Research aim: The aim of our research is to gain insights in the state of the practice of reporting empirical studies of OSS in order to identify the gaps to be filled for improving the quality of evidence being provided for OSS. Method: To that end, we decided to systematically review the empirical studies of OSS. A total of 63 papers reporting empirical studies were selected from the four editions of the Proceedings of the International Conference on Open Source Systems. The data were extracted and synthesised from the selected papers for analysis. Results and conclusions: We have found that the quality of the reported OSS-related empirical studies needs to be significantly improved. Based on the results of our systematic review and general principles of reporting good empirical research, we present a set of guidelines for reporting OSS-related empirical studies. The suggested guidelines are expected to help the research community to improve the quality of reported studies.

Research friendly software repositories - Herraiz, I.; Robles, G.; Gonzalez-Barahona, J.M. (Proceedings of the joint international and annual ERCIM workshops on Principles of software evolution (IWPSE) and software evolution (Evol) workshops, 2009)
What is the future of software evolution? In 1974, Meir M. Lehman had a vision of software evolution being driven by empirical studies of software repositories, and of a theory based on those empirical results. However, that scenario is yet to come. Software evolution studies are often based on a few cases, because the needed information is scarce, dispersed and incomplete. Their conclusions are not generalizable, slowing down the progress of this research discipline. Libre (free / open source) software supposes an opportunity to alleviate this situation. In this paper we describe the existing approaches to provide research datasets that are mining libre software repositories, and propose an agenda based on the concept of research friendly software repositories, which provides finer granularity and integrated data.
Keywords: flossmetrics; flossmole cited

Returns from social capital in open source software networks - Méndez-Durón, Rebeca; García, Clara E. (Journal of Evolutionary Economics, 2009)
Open Source Software projects base their operation on a collaborative structure for knowledge exchange in the form of provision or reception of information, expertise, and feedback on the creation of source code. Here, we address the direction of these knowledge flows among projects throughout social networks and their impact on project success. We identify the roles of membership or contribution that individuals play within projects. We found that connections through contributors who bring their knowledge to the project, improve project success, and that connection through members, who transfer their knowledge towards other projects, enhance project success. Finally, we found that ties through shared membership and contributions hamper project success. The analysis of knowledge flows and their impact on project success imply a translation of returns from investment in social capital, where investment takes the shape of knowledge flows and the returns mean the projects' diffusion over the network.
Keywords: contributors; developers; games; gpl; project success; roles; social capital; social network analysis; social networks; sourceforge; srda; teams

Roitzsch: The Mathematics of Obscurity: On the Trustworthiness of Open Source - Hermann Härtig; Claude-joachim Hamann; Michael Roitzsch; Technische Universität Dresden (9th Workshop on the Economics of Information Security (WEIS), 2009)
It is more difficult to find errors when source code is secret. More people search for errors when source code is public. These counteracting effects are pivotal to the question whether openness fosters security. Errors in software are found by people with either constructive contribution or exploitation in mind. Focusing exclusively on this discovery aspect, we present a probabilistic model, which allows us to compare the open source and closed source situations. We start out with our assumptions explained using a simple introductory model. We then extend this to what we believe to be an adequate model of a bug-hunting process conducted by multiple competing parties. The model employs an asymmetric race paradigm. One of the surprising results is that even an arbitrarily large group with good intentions cannot safely dominate the evil attackers. Instead, they are limited by a significant upper bound in their winning chances.

The role of patch review in software evolution: an analysis of the mozilla firefox - Mehrdad Nurolahzade (The joint international and annual ERCIM workshops on Principles of software evolution (IWPSE) and software evolution (Evol) workshops, 2009)
Patch review is the basic mechanism for validating the design and implementation of patches and maintaining consistency in some commercial and Free/Libre/Open Source Software (FLOSS) projects. We examine the inner-workings of the development process of the successful and mature Mozilla foundation and highlight how different parties involved affect and steer the process. Although reviewers are the primary actors in the patch review process, success in the process can only be achieved if the community supports reviewers adequately. Peer developers play the supporting role by offering insight and ideas that help create more quality patches. Moreover, they reduce the huge patch backlog reviewers have to clear by identifying and eliminating immature patches.
Keywords: inspection; open source development

The Role of Software Licenses in Open Architecture Ecosystems - Alspaugh, Thomas; Hazeline U. Asuncion; Walt Scacchi (International Workshop on Software Ecosystems, in conjunction with the International Conference on Software Reuse, 2009)

rv you're dumb: Identifying Discarded Work in Wiki Article History - Ekstrand, M.D.; Riedl, J.T. (The Fifth International Symposium on Wiki's and Open Collaboration, 2009)

Security of Open Source and Closed Source Software: An Empirical Comparison of Published Vulnerabilities - Schryen, Guido (AMCIS 2009 Proceedings, 2009)
Reviewing literature on open source and closed source security reveals that the discussion is often determined by biased attitudes toward one of these development styles. The discussion specifically lacks appropriate metrics, methodology and hard data. This paper contributes to solving this problem by analyzing and comparing published vulnerabilities of eight open source software and nine closed source software packages, all of which are widely deployed. Thereby, it provides an extensive empirical analysis of vulnerabilities in terms of mean time between vulnerability disclosures, the development of disclosure over time, and the severity of vulnerabilities, and allows for validating models provided in the literature. The investigation reveals that (a) the mean time between vulnerability disclosures was lower for open source software in half of the cases, while the other cases show no differences, (b) in contrast to literature assumption, 14 out of 17 software packages showed a significant linear or piecewise linear correlation between time and the number of published vulnerabilities, and (c) regarding the severity of vulnerabilities, no significant differences were found between open source and closed source.
Keywords: closed source software; empirical comparison; open source software; security; Vulnerabilities

Short and Tweet: Experiments on Recommending Content from Information - Chen, J; Nairn, R.; Nelson, L.; Bernstein, M.; Chi, E. (Proceedings of the 28th annual conference on Human Factors in Computing Systems, 2009)

Software Engineering in Practice: Design and Architectures of FLOSS Systems - Capiluppi, Andrea; Knowles, Thomas (OSS2009: Open Source Ecosystems: Diverse Communities Interacting (IFIP 2.13), 2009)
Free/Libre/Open Source Software (FLOSS) practitioners and developers are typically also users of their own systems: as a result, traditional software engineering (SE) processes (e.g., the requirements and design phases), take less time to articulate and negotiate among FLOSS developers. Design and requirements are kept more as informal knowledge, rather than formally described and assessed. This paper attempts to recover the SE concepts of software design and architectures from three FLOSS case studies, sharing the same application domain (i.e., Instant Messaging). Its first objective is to determine whether a common architecture emerges from the three systems, which can be used as shared knowledge for future applications. The second objective is to determine whether these architectures evolve or decay during the evolution of these systems. The results of this study are encouraging: albeit no explicit effort was done by FLOSS developers to define a high-level view of the architecture, a common shared architecture could be distilled for the Instant Messaging application domain. It was also found that, for two of the three systems, the architecture becomes better organised, and the components better specified, as long as the system evolves in time.

Software Informatics? - Jones, M. Cameron; Michael B Twidale (Proceedings, iConference 2009, 2009)
The paper proposes the term 'software informatics' to describe research on the individual, collaborative, and social aspects of software production and use, spanning multiple representations of software from design, to source code, to application. It does this with a particular focus on information processes around software development. As more applications are web-based or available online for download and increasing amounts of source code is also available online, the information processes surrounding software are changing the way that software is created, appropriated and redesigned. Traditional distinctions between software developer and end-user are blurring, with software development processes occurring along a continuum of the proportion of original code written to develop the application, from build from scratch, through library and API calls, copy-paste programming, web mashup development, end-user programming, to creative design through the selection and combination of existing applications. All these design activities have much in common and can benefit from being studied as a whole.

Software Licenses, Open Source Components, and Open Architectures - Alspaugh, Thomas; Hazeline U. Asuncion; Walt Scacchi (Sixth Annual Acquisition Research Symposium, 2009)

SourcererDB: An aggregated repository of statically analyzed and cross-linked open source Java projects - Ossher, Joel; Bajracharya, Sushil; Linstead, Erik; Baldi, Pierre; Lopes, Cristina (2009 6th IEEE International Working Conference on Mining Software Repositories (MSR)2009 6th IEEE International Working Conference on Mining Software Repositories, 2009)
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

SourcererDB: An aggregated repository of statically analyzed and cross-linked open source Java projects - Ossher, Joel; Bajracharya, Sushil; Linstead, Erik; Baldi, Pierre; Lopes, Cristina (2009 6th IEEE International Working Conference on Mining Software Repositories (MSR), 2009)
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

Strategies for Improving Open Source Software Usability - Zhao, Luyin; Deek, Fadi P.; McHugh, James A. (International Journal of Open Source Software and Processes, 2009)
The Open Source Software (OSS) movement has had enormous impact on how software is created and continues to attract interest from researchers, software developers and users. A factor that may be inhibiting OSS from achieving greater success is usability, a fundamental characteristic to user acceptance of software. Motivated by the uniquely user-driven nature of the open source model and the extensive user base that participates in OSS projects, the authors propose an exploratory learning method and an associated web-based inspection environment that enables non-experts to contribute to open source usability inspection. This tool uses patternbased usability guidelines to help identify usability knowledge during inspection. The method emphasizes outlining and exploration features which the authors have formally evaluated and the results of which are described. Data collected from a qualitative study indicates positive impact of the proposed method in helping end-users inspect software and achieve better results in discovering usability problems.

Studying the use of developer IRC meetings in open source projects - Shihab, Emad; Zhen Ming Jiang; Hassan, Ahmed E. (2009 IEEE International Conference on Software Maintenance (ICSM), 2009)
Open source developers communicate with each other via various online outlets. Thus far, mailing lists have been the main coordination mechanism. However, our previous study shows that the use of developer IRC meetings is increasing in recent years. In this paper, we perform a study on the IRC meetings of two large open source projects: the GTK+ and Evolution projects. We explore three dimensions: who participates in the meetings, what do they discuss and how do they run the meetings. We find (1) that a small and stable number of the participants contribute the majority of messages in meetings, (2) that there are commonly discussed topics as well as project specific topics (3) that meeting styles vary across different projects.
Keywords: evolution; gtk; irc

Succession: Measuring Transfer of Code and Developer Productivity - Audris Mockus (2009 International Conference on Software Engineering, 2009)

Supporting Situation Awareness in FLOSS Projects by Semantical Aggregation of Tools Feeds - Quang Vu Dang; Christian Bac; Olivier Berger; Valentin Vlasceanu (Internet-Based Systems (SITIS 2009)2009 Fifth International Conference on Signal Image Technology and Internet Based Systems, 2009)
It is rather difficult to monitor or visualize what can be the contribution of a member in a collaboration project, especially when the project uses multiple tools to produce its results. This is the case for collaborative development of FLOSS software, that uses Wiki, bug tracker, mailing lists and source code management tools. This paper presents an approach to data collection by using aggregation of feeds published by the different tools of a software forge. To allow this aggregation, collected data is semantically reformatted into Semantic Web standards: RDF, DC, DOAP, FOAF and EvoOnt. Resulting data can then be processed, re-published or displayed to project members. This approach was used to implement a supervision module that is integrated into the PicoForge platform. This module is able to draw a live graph of the social community out of the different sources of data, and in turn exports semantic feeds for other uses.

Supporting the user experience in free/libre/open source software development - Bach, Paula (PhD Thesis, THE PENNSYLVANIA STATE UNIVERSITY, 2009)
With the increasing number and awareness of free/libre/open source software (FLOSS) projects, Internet users can download a FLOSS tool that meets just about any need. The user experience of projects, however, varies greatly and identifying FLOSS projects that offer a positive user experience (UX) is challenging. FLOSS projects center on software developer activities with little attention to user-centered design activities that could increase the user experience on the project. The purpose of this dissertation is to understand open source software ecology in order to bring support for user experience design activities on FLOSS projects. CodePlex, an open source project hosting website, serves as the open source software ecology. The research consists of two phases, a descriptive science phase and a design science phase. In the descriptive phase fieldwork in the form of ethnomethodologically informed ethnography describes the everyday activities of three groups: the team that produces CodePlex, the participants who use CodePlex to produce open source projects, and user experience practitioners who bring their expertise to design software with a positive user experience. The descriptive phase also includes an analysis of activity awareness of the three groups. The design science phase consists of a claims analysis that provides design rationale for a design that proposes to support UX activities on CodePlex. The results show that activity awareness contributes to the socio-technical solution where UX activities can be supported as a new community of practice, with features that support building social capital. The UX support features include a UX workspace where UX contributors recognize their value and other features that support the presence of UX throughout the project site and the CodePlex community. This dissertation contributes empirical materials from the descriptions of everyday activities of the three groups and analytic materials generated from the activity awareness and claims analyses that are translated into design representations. Specifically the contributions include (1) mechanisms of articulation work of the three groups and how the mechanisms contribute to the design representation; (2) the demonstration of a translation science in computersupported cooperative work (CSCW) and human-computer interaction (HCI); and (3) an understanding of how UX activities and software engineering activities integrate.
Keywords: codeplex

A Survey of Usability Practices in Free/Libre/Open Source Software - Paul, Celeste (OSS2009: Open Source Ecosystems: Diverse Communities Interacting (IFIP 2.13), 2009)
A review of case studies about usability in eight Free/Libre/Open Source Software (FLOSS) projects showed that an important issue regarding a usability initiative in the project was the lack of user research. User research is a key component in the user-centered design (UCD) process and a necessary step for creating usable products. Reasons why FLOSS projects suffered from a lack of user research included poor or unclear project leadership, cultural differences between developer and designers, and a lack of usability engineers. By identifying these critical issues, the FLOSS usability community can begin addressing problems in the efficacy of usability activities and work towards creating more usable FLOSS products.

A Survey on Firms’ Participation in Open Source Community Projects - Capra, Eugenio; Francalanci, Chiara; Merlo, Francesco; Rossi Lamastra, Cristina (OSS2009: Open Source Ecosystems: Diverse Communities Interacting (IFIP 2.13), 2009)
The role of firms in commercial Open Source projects (e.g., former MySQL, EnterpriseDB, SugarCRM) is a consolidated and generally accepted fact. On other hand, community Open Source projects, which are built upon communities and not directly associated with firms, are commonly perceived to be based mainly on the work of volunteers. Up to now, firms’ role in these projects has been poorly investigated. We conducted a survey on 1,302 SourceForge.net projects to inquire about the level and the typology of involvement of firms. We propose three different models for firm participation and provide empirical evidence on their diffusion in SourceForge.net.

The System for Population Kinetics - Vicini, Paolo (International Journal of Open Source Software and Processes, 2009)
This chapter describes the System for Population Kinetics (SPK), a novel Web service for performing population kinetic analysis. Population kinetic analysis is a widely-used tool for extracting information about the probability distributions of unknown parameters in kinetic models. The statistical population model is usually hierarchical, with a nested structure encompassing both variation between subjects and residual unexplained variation associated with the model predictions. The complexity of the analysis is largely driven by the nonlinearity of the models employed. Here, we provide a concise introduction to the topic and a historical perspective for the benefit of the reader who is new to these concepts. Next, we briefly describe the SPK open source system and its multi-tiered architecture, indicating the user goals it set to achieve and elucidating its practical usage with examples.

Tagommenders: Connecting Users to Items through Tags - Sen, S.; Vig, J.; Riedl, J. (International World Wide Web Conference, 2009)

Tagsplanations: Explaining Recommendations using Tags - Vig, J.; Sen, S.; Riedl, J. (International Conference on Intelligent User Interfaces, 2009)
Keywords: recommender; SYSTEMS; tagging,

Teaching Software Engineering with Free/Libre Open Source Projects - Ioannis Stamelos (International Journal of Open Source Software and Processes, 2009)
One of the major problems in software engineering education is the involvement of students in real world software projects. Industry projects are a solution, but in many cases they are hard to find and student participation can be problematic due to cultural, familiarization and other practical reasons. The abundance of Free / Libre Open Source Software (FLOSS) projects is a neat solution, offering multi-lingual, multicultural environments in virtually every application domain, at different levels of project size, maturity, organization etc. The paper analyzes how acquisition of practical experience on several basic and advanced software engineering topics can be achieved by working in a FLOSS project. The kind of skills that can be acquired are those requested by the Overview Report for Computing Curricula by ACM and topics examined are those of the Software Engineering Body of Knowledge, by IEEE. Also software engineering areas that require special care or that may not prove suitable for such treatment are identified. Various isolated teaching cases pertaining to this approach are presented and discussed.
Keywords: curriculum; education; teaching; undergraduate

Tools for the Study of the Usual Data Sources found in Libre Software Projects - Gregorio Robles; González-Barahona, Jesús M.; Izquierdo-Cortazar, Daniel; Herraiz, Israel (International Journal of Open Source Software and Processes, 2009)
Due to the open nature of Free/Libre/Open Source software projects, researchers have gained access to a rich set of development-related information. Although this information is publicly available on the Internet, obtaining and analyzing it in a convenient way is not an easy task and many considerations have to be taken into account. In this paper we present the most important data sources that can be found in libre software projects and that are studied by the research community: source code, source code management systems, mailing lists and bug tracking systems. We will give advice for the problems that can be found when retrieving and preparing the data sources for a posterior analysis, as well as provide information about the tools that support these tasks.
Keywords: bug tracking systems; data sources; mailing lists; scm; tools

Tracking concept drift of software projects using defect prediction quality - Ekanayake, Jayalath; Tappolet, Jonas; Gall, Harald C.; Bernstein, Abraham (2009 6th IEEE International Working Conference on Mining Software Repositories (MSR)2009 6th IEEE International Working Conference on Mining Software Repositories, 2009)
Defect prediction is an important task in the mining of software repositories, but the quality of predictions varies strongly within and across software projects. In this paper we investigate the reasons why the prediction quality is so fluctuating due to the altering nature of the bug (or defect) fixing process. Therefore, we adopt the notion of a concept drift, which denotes that the defect prediction model has become unsuitable as set of influencing features has changed - usually due to a change in the underlying bug generation process (i.e., the concept). We explore four open source projects (Eclipse, OpenOffice, Netbeans and Mozilla) and construct file-level and project-level features for each of them from their respective CVS and Bugzilla repositories. We then use this data to build defect prediction models and visualize the prediction quality along the time axis. These visualizations allow us to identify concept drifts and - as a consequence - phases of stability and instability expressed in the level of defect prediction quality. Further, we identify those project features, which are influencing the defect prediction quality using both a tree induction-algorithm and a linear regression model. Our experiments uncover that software systems are subject to considerable concept drifts in their evolution history. Specifically, we observe that the change in number of authors editing a file and the number of defects fixed by them contribute to a project's concept drift and therefore influence the defect prediction quality. Our findings suggest that project managers using defect prediction models for decision making should be aware of the actual phase of stability or instability due to a potential concept drift.
Keywords: bugzilla; cvs; defect prediction; eclipse; mozilla; netbeans; openoffice

Trust issues in open source software development - Orsila, Heikki; Geldenhuys, Jaco; Ruokonen, Anna; Hammouda, Imed (Proceedings of the Warm Up Workshop for ACM/IEEE ICSE 2010, 2009)
Open source software and the associated development model holds great promise, but the issue of trust is a major challenge. This applies to companies wishing to adopt the open source model but also within open source projects. We investigate this issue by data mining open source repositories to study two related phenomena: update propagation and distributed version control.
Keywords: ffmpeg; trust; version control; zlib

Two peers are better than one: aggregating peer reviews for computing assignments is surprisingly accurate - Reily, K.; Finnerty, P.L.; Terveen, L. (ACM 2009 International Conference on Supporting Group Work, 2009)

Undergraduate Research Opportunities in OSS - Boldyreff, Cornelia; Capiluppi, Andrea; Knowles, Thomas; Munro, James (OSS2009: Open Source Ecosystems: Diverse Communities Interacting (IFIP 2.13), 2009)
Using Open Source Software (OSS) in undergraduate teaching in universities is now commonplace. Students use OSS applications and systems in their courses on programming, operating systems, DBMS, web development to name but a few. Studying OSS projects from both a product and a process view also forms part of the software engineering curriculum at various universities. Many students have taken part in OSS projects as well as developers. At the University of Lincoln, under the Undergraduate Research Opportunities Scheme (UROS), undergraduate student researchers have the chance to work over the summer embedded within an existing research centre on a UROS project. Here two such projects within the Centre for Research in Open Source Software (CROSS) are described: Collaborative Development for the XO Laptop (CODEX) and Software Modularity in Open Source Software (SoMOSS). The CODEX project focused on creating resources to support students undertaking software application development for the XO laptop, and the SoMOSS project focused on architectural studies of OSS instant messaging software. Both projects achieved successful research outcomes; more importantly, both student researchers benefited directly from the encouragement and concrete assistance that they received through interaction with the wider OSS research community. Both projects are ongoing and present further research opportunities for students.

Understanding how and why open source contributors use diagrams in the development of Ubuntu - Yatani, Koji; Chung, Eunyoung; Jensen, Carlos; Truong, Khai N. (Proceedings of the 27th international conference on Human factors in computing systems, 2009)
Some of the most interesting differences between Open Source Software (OSS) development and commercial co-located software development lie in the communication and collaboration practices of these two groups of developers. One interesting practice is that of diagramming. Though well studied and important in many aspects of co-located software development (including communication and collaboration among developers), its role in OSS development has not been thoroughly studied. In this paper, we report our investigation on how and why Ubuntu contributors use diagrams in their work. Our study shows that diagrams are not actively used in many scenarios where they commonly would in co-located software development efforts. We describe differences in the use and practices of diagramming, their possible reasons, and present design considerations for potential systems aimed at better supporting diagram use in OSS development.
Keywords: developers; diagramming; interviews; open source software (oss); software development; Ubuntu; visual representation

Understanding Requirements for Open Source Software - Walt Scacchi (Design Requirements Engineering: A Ten-Year Perspective, 2009)

Understanding Sustained Participation in Open Source Software Projects - Fang, Yulin; Neufeld, Derrick (J. Manage. Inf. Syst., 2009)
Prior research into open source software (OSS) developer participation has emphasized individuals' motivations for joining these volunteer communities, but it has failed to explain why people stay or leave in the long run. Building upon Lave and Wenger's theory of legitimate peripheral participation (LPP), this paper offers a longitudinal investigation of one OSS community in which sustained participation is hypothesized to be associated with the coevolution of two major elements of LPP theory: "situated learning" (the process of acting knowledgeably and purposefully in the world) and "identity construction" (the process of being identified within the community). To test this hypothesis, data were collected from multiple sources, including online public project documents, electronic mail messages, tracker messages, and log files. Results from qualitative analyses revealed that initial conditions to participate did not effectively predict long-term participation, but that situated learning and identity construction behaviors were positively linked to sustained participation. Furthermore, this study reveals that sustained participants distinguished themselves by consistently engaging in situated learning that both made conceptual (advising others) and practical contributions (improving the code). Implications and future research are discussed.
Keywords: Communities Of Practice; Legitimate Peripheral Participation; Open Source Projects; Open Source Software Community; Qualitative Study

Understanding the Nature and Production Model of Hybrid Free and Open Source Systems: The Case of Varnish - Zegaye Seifu Wubishet (42nd Hawaii International Conference on System Sciences (HICSS 2009), 2009)
This is a detailed interpretive case study analysis of an open source software project, called Varnish. The conceptual framework is based on the literature covering issues of commons based production models and the organization of open source projects. The comparative analysis reveals that Varnish is a hybrid project, encompassing the features of open source software while managed by a company as a proprietary project would. It is also hybrid in the sense that it employs a combination of hierarchical and commons based peer production model features. This mix of characters addresses a variety of problems related to each of the aforementioned categories.
Keywords: case study; organizational sponsorship; peer production; varnish

On the use of Internet Relay Chat (IRC) meetings by developers of the GNOME GTK+ project - Shihab, Emad; Zhen Ming Jiang; Hassan, Ahmed E. (2009 6th IEEE International Working Conference on Mining Software Repositories (MSR)2009 6th IEEE International Working Conference on Mining Software Repositories, 2009)
Developers of open source projects are distributed across the world. They rely on email, mailing lists, instant messaging, IRC channels and more recently IRC meetings to communicate. Most of the studies thus far focus on the use of mailing lists by OSS developers, however, an increasing number of open source projects are using IRC meetings to hold developer meetings. In this paper, we mine the #gtk-devel IRC meeting channel and study the usage of the IRC meetings held by the GNOME GTK+ core developers and maintainers. We look at three different dimensions: the discussion volume of the meetings, the number of participants attending the meetings and the activity of these participants. Our findings show that IRC meetings are gaining popularity among open source developers and maintainers: the IRC meeting discussions are increasing in volume, have increasing attendance levels, and the participants actively contribute to the meetings. To the best of our knowledge, this is the first study on the use of developer IRC meetings by OSS developers.
Keywords: gnome; gtk; irc; msr challenge

Users of Open Source Software - How do they get help? - Singh, V; Twidale, M.B; Nichols, D.M (HICSS 2009, 2009)
A study was conducted across multiple open source software online technical help communities. This paper presents the types of discussions that occur, the types of questions asked and the type of responses that are given. The implications for socio-technical design are considered, exploring how help requests and discussions can be used to improve future help-giving, documentation and interface and functionality redesign.
Keywords: technical help

Users of Open Source Software - How Do They Get Help? - Singh, Vandana; Michael B Twidale; David M Nichols (42nd Hawaii International Conference on System Sciences (HICSS 2009), 2009)
A study was conducted across multiple open source software online technical help communities. This paper presents the types of discussions that occur, the types of questions asked and the type of responses that are given. The implications for socio-technical design are considered, exploring how help requests and discussions can be used to improve future help-giving, documentation and interface and functionality redesign.
Keywords: technical help

Using association rules to study the co-evolution of production & test code - Lubsen, Zeeger; Zaidman, Andy; Pinzger, Martin (2009 6th IEEE International Working Conference on Mining Software Repositories (MSR)2009 6th IEEE International Working Conference on Mining Software Repositories, 2009)
Unit tests are generally acknowledged as an important aid to produce high quality code, as they provide quick feedback to developers on the correctness of their code. In order to achieve high quality, well-maintained tests are needed. Ideally, tests co-evolve with the production code to test changes as soon as possible. In this paper, we explore an approach based on association rule mining to determine whether production and test code co-evolve synchronously. Through two case studies, one with an open source and another one with an industrial software system, we show that our association rule mining approach allows one to assess the co-evolution of product and test code in a software project and, moreover, to uncover the distribution of programmer effort over pure coding, pure testing, or a more test-driven-like practice.
Keywords: association rules; checkstyle; source code; unit test

Using FLOSS Project Metadata in the Undergraduate Classroom - Squire, Megan; Duvall, Shannon (OSS2009: Open Source Ecosystems: Diverse Communities Interacting (IFIP 2.13), 2009)
This paper describes our efforts to use the large amounts of data available from public repositories of free, libre, and open source software (FLOSS) in our undergraduate classrooms to teach concepts that would have previously been taught using other types of data from other sources.
Keywords: artificial intelligence; database; education; teaching; undergraduate; undergraduate research

Using Latent Dirichlet Allocation for automatic categorization of software - Tian, Kai; Revelle, Meghan; Poshyvanyk, Denys (2009 6th IEEE International Working Conference on Mining Software Repositories (MSR)2009 6th IEEE International Working Conference on Mining Software Repositories, 2009)
In this paper, we propose a technique called LACT for automatically categorizing software systems in open-source repositories. LACT is based on latent Dirichlet Allocation, an information retrieval method which is used to index and analyze source code documents as mixtures of probabilistic topics. For an initial evaluation, we performed two studies. In the first study, LACT was compared against an existing tool, MUDABlue, for classifying 41 software systems written in C into problem domain categories. The results indicate that LACT can automatically produce meaningful category names and yield classification results comparable to MUDABlue. In the second study, we applied LACT to 43 software systems written in different programming languages such as C/C++, Java, C#, PHP, and Perl. The results indicate that LACT can be used effectively for the automatic categorization of software systems regardless of the underlying programming language or paradigm. Moreover, both studies indicate that LACT can identify several new categories that are based on libraries, architectures, or programming languages, which is a promising improvement as compared to manual categorization and existing techniques.
Keywords: categorization; category mining; lact; mudablue; multiple languages; repository

Using Software Archaeology to Measure Knowledge Loss in Software Projects Due to Developer Turnover - Izquierdo-Cortazar, Daniel; Gregorio Robles; Ortega, Felipe; Jesus M. Gonzalez-Barahona (2009 42nd Hawaii International Conference on System Sciences (HICSS 2009), 2009)
Developer turnover can result in a major problem when developing software. When senior developers abandon a software project, they leave a knowledge gap that has to be managed. In addition, new (junior) developers require some time in order to achieve the desired level of productivity. In this paper, we present a methodology to measure the effect of knowledge loss due to developer turnover in software projects. For a given software project, we measure the quantity of code that has been authored by developers that do not belong to the current development team, which we define as orphaned code. Besides, we study how orphaned code is managed by the project. Our methodology is based on the concept of software archaeology, a derivation of software evolution. As case studies we have selected four FLOSS (free, libre, open source software) projects, from purely driven by volunteers to company-supported. The application of our methodology to these case studies will give insight into the turnover that these projects suffer and how they have managed it and shows that this methodology is worth being augmented in future research.
Keywords: attrition; case study; developers; evince; evolution; gimp; growth; knowledge collaboration; lines of code; nautilus; quality; sloc; turnover

Virtual organizational learning in open source software development projects - Yoris A. Au; Darrell Carpenter; Xiaogang Chen; Jan G. Clark (Information & Management, 2009)
We studied virtual organizational learning in open source software (OSS) development projects. Specifically, our research focused on learning effects of OSS projects and the factors that affect the learning process. The number and percentage of resolved bugs and bug resolution time of 118 SourceForge.net OSS projects were used to measure the learning effects. Projects were characterized by project type, number and experience of developers, number of bugs, and bug resolution time. Our results provided evidence of virtual organizational learning in OSS development projects and support for several factors as determinants of performance. Team size was a significant predictor, with mid-sized project teams functioning best. Teams of three to seven developers exhibited the highest efficiency over time and teams of eight to 15 produced the lowest mean time for bug resolution. Increasing the percentage of bugs assigned to specific developers or boosting developer participation in other OSS projects also improved performance. Furthermore, project type introduced variability in project team performance.
Keywords: bug fixing; bugs; learning; Project performance; sourceforge; team size; teams; virtual organization

Visual querying and analysis of large software repositories - Voinea, Lucian; Telea, Alexandru (Empirical Software Engineering, 2009)
We present a software framework for mining software repositories. Our extensible framework enables the integration of data extraction from repositories with data analysis and interactive visualization. We demonstrate the applicability of the framework by presenting several case studies performed on industry-size software repositories. In each study we use the framework to give answers to one or several software engineering questions addressing a specific project. Next, we validate the answers by comparing them with existing project documentation, by interviewing domain experts and by detailed analyses of the source code. The results show that our framework can be used both for supporting case studies on mining software repository techniques and for building end-user tools for software maintenance support.

Visualizing Gnome with the Small Project Observatory - Lungu, Mircea; Malnati, Jacopo; Lanza, Michele (2009 6th IEEE International Working Conference on Mining Software Repositories (MSR)2009 6th IEEE International Working Conference on Mining Software Repositories, 2009)
We analyzed the gnome family of systems with the small project observatory, our online ecosystem visualization platform. We begin by briefly introducing the model of SPO. We then observe and discuss several phases in the activity of the gnome ecosystem. We follow and look at how the contributors are distributed between writing source code and doing other activities such as internationalization. We end with a visual overview of the activity of more than 900 contributors in the 10 years of existence of gnome.
Keywords: bugzilla; contributions; gnome; msr challenge; spo; visualization

Volunteers' involvement in online community based software development - Bo Xu; Donald R. Jones; Bingjia Shao (Information & Management, 2009)
We sought to gain understanding of voluntary developers' involvement in open source software (OSS) projects. Data were collected from voluntary developers working on open source projects. Our findings indicated that a voluntary developer's involvement was very important to his or her performance and that involvement was dependent on individual motivations (personal software needs, reputation and skills gaining expectation, enjoyment in open source coding) and project community factors (leadership effectiveness, interpersonal relationship, community ideology). Our work contributes theoretically and empirically to the body of OSS research and has practical implications for OSS project management.
Keywords: age; developers; effectiveness; function points; ideology; leadership; MOTIVATION; scm; sourceforge; status; Survey; team size; Volunteers

Weaving a Semantic Web across OSS repositories: a spotlight on btslink, UDD, SWIM - Olivier Berger; Valentin Vlasceanu; Christian Bac; Laurière, Stéphane (4th Workshop on Public Data about Software Development (WoPDaSD 2009), 2009)
Several public repositories and archives of facts about libre software projects, developed either by open source communities or by research communities, have been flourishing over the Web in the recent years. These enable new analysis and support new quality assurance tasks. By using Semantic Web techniques, the databases containing data about open-source software projects development can be interconnected, hence letting OSS partakers identify resources, annotate them and further interlink them using dedicated properties, collectively designing a distributed semantic graph. Such links expressed with standard Semantic techniques are paving the way to new applications (including ones meant for “end-users”). For instance this may have an impact on the way research efforts are conducted (less fragmented), and could also be used by development communities to improve Quality Assurance tasks. A goal of the research conducted within the HELIOS project, is to address bugtracker synchronization issues. For that, the potential of using Semantic Web technologies in navigating between many different bugtracker systems scattered all over the open source ecosystem is being investigated. This position paper presents some existing tools, projects and models proposed by OSS actors that are complementary to research initiatives, and that are likely to lead to useful future developments: UDD (Ultimate Debian Database) and bts-link, developed by the Debian community, and SWIM (Semantic Web enabled Issue Manager) developed by Mandriva. The HELIOS team welcomes comments on the future paths that can be considered in using the Semantic Web approach for improving these projects.
Keywords: bts-link; bug tracker; bugzilla; debian; ecosystem; helios; mandriva; semantic Web; swim; udd

On what basis to recommend: Changesets or interactions? - Rastkar, Sarah; Murphy, Gail C. (2009 6th IEEE International Working Conference on Mining Software Repositories (MSR)2009 6th IEEE International Working Conference on Mining Software Repositories, 2009)
Different flavours of recommendation systems have been proposed to help software developers perform software evolution tasks. A number of these recommendation systems are based on changesets. When changeset information is used, recommendations are based on only the end result of the activity undertaken to complete a task. In this paper, we report on an investigation that compared how recommendations based on changesets compare to recommendations based on interactions collected as a programmer performed the task that resulted in a changeset. To provide a common basis for the comparison, our investigation considered how bug reports considered similar based on changeset information compare to bug reports considered similar based on interaction information. We found that there is no direct relationship between the bug reports found similar with the different methods, suggesting that each comparison methods captures a different aspect of the problem.
Keywords: bug reports; changeset; eclipse; mylyn

What Constitutes Open Source? A Study of the Vista Electronic Medical Record Software - Noll, John (OSS2009: Open Source Ecosystems: Diverse Communities Interacting (IFIP 2.13), 2009)
Strictly speaking, Open Source Software is any program that is covered by an Open Source Software license. However, the notion of Open Source Software Development conjures images of high-quality, market dominating products developed by armies of volunteer programmers, who work only for the joy of programming. Certainly, banner projects like Apache, the Linux kernel, and Mozilla/Firefox resemble this notion, even if they do employ significant numbers of paid programmers. This paper examines three Open Source Software projects related to the Vista Electronic Medical Record system developed and maintained by the U.S. Department of Veterans Affairs and released to the public domain. While all three claim to be “Open Source” projects, there is considerable deviation from the strong community-oriented model that Linux, Apache, and Mozilla represent.

What Does It Take to Develop a Million Lines of Open Source Code? - Fernandez-Ramil, Juan; Izquierdo-Cortazar, Daniel; Mens, Tom (OSS2009: Open Source Ecosystems: Diverse Communities Interacting (IFIP 2.13), 2009)
This article presents a preliminary and exploratory study of the relationship between size, on the one hand, and effort, duration and team size, on the other, for 11 Free/Libre/Open Source Software (FLOSS) projects with current size ranging between between 0.6 and 5.3 million lines of code (MLOC). Effort was operationalised based on the number of active committers per month. The extracted data did not fit well an early version of the closed-source cost estimation model COCOMO for proprietary software, overall suggesting that, at least to some extent, FLOSS communities are more productive than closed-source teams. This also motivated the need for FLOSS-specific effort models. As a first approximation, we evaluated 16 linear regression models involving different pairs of attributes. One of our experiments was to calculate the net size, that is, to remove any suspiciously large outliers or jumps in the growth trends. The best model we found involved effort against net size, accounting for 79 percent of the variance. This model was based on data excluding a possible outlier (Eclipse), the largest project in our sample. This suggests that different effort models may be needed for certain categories of FLOSS projects. Incidentally, for each of the 11 individual FLOSS projects we were able to model the net size trends with very high accuracy (R 2 ≥ 0.98). Of the 11 projects, 3 have grown superlinearly, 5 linearly and 3 sublinearly, suggesting that in the majority of the cases accumulated complexity is either well controlled or don’t constitute a growth constraining factor.

What Makes Free/Libre Open Source Software (FLOSS) Projects Successful? An Agent-Based Model of FLOSS Projects - Radtke, Nicholas P.; Janssen, Marco A.; Collofello, James S. (International Journal of Open Source Software and Processes, 2009)
The last few years have seen a rapid increase in the number of Free/Libre Open Source Software (FLOSS) projects. Some of these projects, such as Linux and the Apache web server, have become phenomenally successful. However, for every successful FLOSS project there are dozens of FLOSS projects which never succeed. These projects fail to attract developers and/or consumers and, as a result, never get off the ground. The aim of this research is to better understand why some FLOSS projects flourish while others wither and die. This article presents a simple agent-based model that is calibrated on key patterns of data from SourceForge, the largest online site hosting open source projects. The calibrated model provides insight into the conditions necessary for FLOSS success and might be used for scenario analysis of future developments of FLOSS.
Keywords: Agent-Based Model; Emergent Properties; FLOSS; open source; Prediction Success; Simulation

Is Wikipedia Growing a Longer Tail? - Lam, S.K.; Riedl, J. (ACM 2009 International Conference on Supporting Group Work, 2009)

Wikipedians are born, not made: a study of power editors on Wikipedia - Panciera, K.; Halfaker, A.; Terveen, L. (ACM 2009 International Conference on Group Work, 2009)
Keywords: computer-supported; cooperative; interaction; web-based; work,

Workshop – Serious Games and Open Source: Practice and Futures - Backlund, Per; Lundell, Björn; Walt Scacchi (OSS2009: Open Source Ecosystems: Diverse Communities Interacting (IFIP 2.13), 2009)
Computer games are increasingly used throughout our society with people playing on the bus, at home and at work. Computer games thus affect larger and larger number of people and areas in the society of today. There are even scholars who advocate that games create better environments for learning than traditional classrooms. This situation motivates the use of games and game technology for additional purposes, e.g. education, training, health care or marketing.

Adoption of Open Source in the Software Industry - Hauge, Øyvind; Sørensen, Carl-Fredrik; Conradi, Reidar (OSS2008: Open Source Development, Communities and Quality (IFIP 2.13), 2008)
Is Open Source Software (OSS) undergoing a transformation to a more commercially viable form? We have performed a survey to investigate the adoption of OSS in the Norwegian software industry. The survey was based on an extensive screening of software companies, with more than 700 responses. The survey results support the transformation predicted by Fitzgerald [4]. Close to 50% of the software industry integrate OSS components into vertical solutions serving all major business sectors. In addition, more than 30% of the 95 respondents in our survey have more than 40% of their income from OSS related services or software. The extensive adoption of OSS in the software industry may be a precursor of the OSS adoption in other business sectors.

Advances in the Sourceforge Research Data Archive - Matthew Van Antwerp; Madey, Greg (3rd Workshop on Public Data about Software Development (WoPDaSD 2008), 2008)
The SourceForge Research Data Archive (SRDA), located at http://zerlot.cse.nd.edu, is a collection of Open Source Software (OSS) data and resources [6]. Over 100 researchers worldwide use the archive for research in many ﬁelds. In this paper, we describe the recent changes, the work in progress, and future plans for making the archive easier to use and for allowing more advanced research to be done with the data available.
Keywords: forge; forges; repositories; repository; sourceforge; srda

The allocation of collaborative efforts in open-source software - den Besten, Matthijs; Jean-Michel Dalle; Galia, Fabrice (Information Economics and Policy, 2008)
The article investigates the allocation of collaborative efforts among core developers (maintainers) of open-source software by analyzing on-line development traces (logs) for a set of 10 large projects. Specifically, we investigate whether the division of labor within open-source projects is influenced by characteristics of software code. We suggest that the collaboration among maintainers tends to be influenced by different measures of code complexity. We interpret these findings by providing preliminary evidence that the organization of open-source software development would self-adapt to characteristics of the code base, in a 'stigmergic' manner.
Keywords: age; apache; complexity; cvs; division of labor; functions; gaim; gcc; ghostscript; lines of code; loc; log files; mozilla; netbsd; openssh; postgresql; python; revision control; scm; size; source code; Stigmergy; version control

Altruism, Selfishness, and Destructiveness on the Social Web - Riedl, J. (5th International Conference on Adaptive Hypermedia and Adaptive Web-Based Systems, 2008)

AMAP: automatically mining abbreviation expansions in programs to enhance software maintenance tools - Hill, Emily; Fry, Zachary P.; Boyd, Haley; Sridhara, Giriprasad; Novikova, Yana; Pollock, Lori; Vijay-Shanker, K. (Proceedings of the 2008 international working conference on Mining software repositories, 2008)
When writing software, developers often employ abbreviations in identifier names. In fact, some abbreviations may never occur with the expanded word, or occur more often in the code. However, most existing program comprehension and search tools do little to address the problem of abbreviations, and therefore may miss meaningful pieces of code or relationships between software artifacts. In this paper, we present an automated approach to mining abbreviation expansions from source code to enhance software maintenance tools that utilize natural language information. Our scoped approach uses contextual information at the method, program, and general software level to automatically select the most appropriate expansion for a given abbreviation. We evaluated our approach on a set of 250 potential abbreviations and found that our scoped approach provides a 57% improvement in accuracy over the current state of the art.
Keywords: automatic abbreviation expansion; azureus; itext.net; liferay; maintenance; natural language; openoffice.org; program comprehension; source code; tiger envelopes; tools

Analysis of Coordination Between Developers and Users in the Apache Community - Kamei, Yasutaka; Matsumoto, Shinsuke; Maeshima, Hirotaka; Onishi, Yoji; Ohira, Masao; Matsumoto, Ken-ichi (OSS2008: Open Source Development, Communities and Quality (IFIP 2.13), 2008)
Coordination is one of the keys for the success of open source software (OSS) communities because geographically distributed members need to collaborate on their work using communication tools (e.g., mailing lists, bulletin board systems, bug tracking systems, and so on). In this paper, we investigated the informal social structure among developers and users by analyzing two mailing lists of developers and users in the Apache community based on betweenness centrality, one centrality measure proposed by Freeman. From the analysis results, we found that (1) participants with high betweenness coordinated activities between developers and users and (2) some participants have been functioning as coordinators in the community for a long time.
Keywords: apache; email; mailing list

Analyzing the evolution of eclipse plugins - Wermelinger, Michel; Yu, Yijun (Proceedings of the 2008 international working conference on Mining software repositories, 2008)
Eclipse is a good example of a modern component-based complex system that is designed for long-term evolution, due to its architecture of reusable and extensible components. This paper presents our preliminary results about the evolution of Eclipse's architecture, based on a lightweight and scalable analysis of the metadata in Eclipse's sources. We find that the development of Eclipse follows a systematic process: most architectural changes take place in milestones, and maintenance releases only make exceptional changes to component dependencies. We also found a stable architectural core that remains since the first release.
Keywords: architectural evolution; cvs; eclipse; metadata; msr challenge; releases; source code

Applying Open Source Development Practices Inside a Company - Juho Lindman; Rossi, Matti; Marttiin, Pentti (OSS2008: Open Source Development, Communities and Quality (IFIP 2.13), 2008)
Open Source Software development is seen as a panacea by many companies. The promise of community-style development, innovation and cost savings drive the wider adoption of OSS in companies. However, it is still difficult to institutionalize the open and agile culture of sharing innovation especially into larger departmentalized organizations. The aim of this research paper is to investigate the characteristics of one successful OSS development implementation approach limited inside a company (Inner source). Based on our data, we argue that there are possibilities for employing OSS as a new kind of development process within a company and leveraging thus the innovation potential inside the company.

An approach to detecting duplicate bug reports using natural language and execution information - Wang, Xiaoyin; Zhang, Lu; Xie, Tao; Anvik, John; Sun, Jiasu (Proceedings of the 30th international conference on Software engineering, 2008)
An open source project typically maintains an open bug repository so that bug reports from all over the world can be gathered. When a new bug report is submitted to the repository, a person, called a triager, examines whether it is a duplicate of an existing bug report. If it is, the triager marks it as DUPLICATE and the bug report is removed from consideration for further work. In the literature, there are approaches exploiting only natural language information to detect duplicate bug reports. In this paper we present a new approach that further involves execution information. In our approach, when a new bug report arrives, its natural language information and execution information are compared with those of the existing bug reports. Then, a small number of existing bug reports are suggested to the triager as the most similar bug reports to the new bug report. Finally, the triager examines the suggested bug reports to determine whether the new bug report duplicates an existing bug report. We calibrated our approach on a subset of the Eclipse bug repository and evaluated our approach on a subset of the Firefox bug repository. The experimental results show that our approach can detect 67%-93% of duplicate bug reports in the Firefox bug repository, compared to 43%-72% using natural language information alone.
Keywords: bug report; duplicate bug report; execution information; information retrieval; natural language

Archetypal Internet-Scale Source Code Searching - Umarji, Medha; Sim, Susan; Lopes, Crista (OSS2008: Open Source Development, Communities and Quality (IFIP 2.13), 2008)
Programmers often search for Open Source code to use in their projects. To understand how and why programmers search for source code, we onducted a web-based survey and collected data from 69 respondents, including 58 specific examples of searches. Analyzing these anecdotes, we found that they could be categorized along two orthogonal dimensions: motivation (reuse vs. reference example) and size of search target. The targets of these searches could range in size from a block (a few lines of code) to a subsystem (e.g. library or API), to an entire system. Within these six combinations of motivations and target sizes, nine repeating motifs, or archetypes, were created to characterize Internet-scale source code searching. Tools used for searching and the criteria for selecting a component are also discussed. We conclude with guidance on how these archetypes can inform better evaluation of Internet-scale code search engines, as well as the design of new features for these tools.

Are FLOSS developers committing to CVS/SVN as much as they are talking in mailing lists? Challenges for Integrating data from Multiple Repositories - Sowe, Sulayman K.; Samoladas, Ioannis; Ioannis Stamelos; Lefteris Angelis (3rd Workshop on Public Data about Software Development (WoPDaSD 2008), 2008)
This paper puts forward a framework for investigating Free and Open Source Software (F/OSS) developers activities in both source code and mailing lists repositories. We used data dumps of fourteen pro jects from the FLOSSMetrics (FM) retrieval system. Our intentions are (i) to present a possible methodology, its advantages and disadvantages which can beneﬁt future researchers using some aspects of the FM retrieval system’s data dumps, and (ii) discuss our initial research results on the contributions developers make to both coding and lists activities.
Keywords: cvs; cvsanaly; developers; email; email archives; flossmetrics; mailing list; mlstats; source code

Assessing Innovation in the Software Sector: Proprietary vs. FOSS Production Mode. Preliminary Evidence from the Italian Case - Dario Lorenzi; Cristina Rossi (OSS2008: Open Source Development, Communities and Quality (IFIP 2.13), 2008)
Innovation in the software sector is a widely debated issue. Which are the most important dimensions to assess innovation in this field? Can we measure innovative processes carried out by software companies and what kind of innovation do they develop? Are FOSS solutions more innovative than proprietary ones? These are the research questions we endeavor to answer in this paper providing some empirical evidence, obtained using an original methodology of collecting experts’ evaluations on the innovation level of 134 solutions provided by a group of Italian Small and Medium Enterprises.

Asynchronous Decision-Making in Distributed Teams - Li, Qing; Robert Heckman; Eileen Allen; Kevin Crowston; Eseryel, U. Yeliz; James Howison; Andrea Wiggins (Computer Supported Cooperative Work 2008, 2008)
Extensive use of CSCW applications can influence group decision-making practices. Unlike previous research focused on the influence of synchronous ICTs, our study examines how group decisions are made in asynchronous communication channels. Our inductive qualitative analysis of 360 decision episodes of six FLOSS projects revealed diversity in decision-making practices, which appears to be related to differences in project effectiveness and task type. We also find that standardization of procedures through CSCW tools transforms the nature of some software development work from non-routine to standard procedure.

Author Entropy: A Metric for Characterization of Software Authorship Patterns - Taylor, Quinn C.; Stevenson, James E.; Delorey, Daniel P.; Knutson, Charles D. (3rd Workshop on Public Data about Software Development (WoPDaSD 2008), 2008)
We propose the concept of author entropy and describe how ﬁle-level entropy measures may be used to understand and characterize authorship patterns within individual ﬁles, as well as across an entire project. As a proof of concept, we compute author entropy for 28,955 ﬁles from 33 open-source projects. We explore patterns of author entropy, identify techniques for visualizing author entropy, and propose avenues for further study.
Keywords: developers; entropy; flossmole; sourceforge

Biobazaar: The Open Source Revolution and Biotechnology - Janet Hope (Harvard University Press, 2008)

Branching and merging in the repository - Spacco, Jamie; Williams, Chadd C. (the 2008 international workshopProceedings of the 2008 international workshop on Mining software repositories - MSR '08, 2008)
Two of the most complex operations version control software allows a user to perform are branching and merging. Branching provides the user the ability to create a copy of the source code to allow changes to be stored in version control but outside of the trunk. Merging provides the user the ability to copy changes from a branch to the trunk. Performing a merge can be a tedious operation and one that may be error prone. In this paper, we compare file revisions found on branches with those found on the trunk to determine when a change that is applied to a branch is moved to the trunk. This will allow us to study how developers use merges and to determine if merges are in fact more error prone than other commits.
Keywords: argouml; changes; cvs2svn; diffj; revision; scm; source code; version control

Bug Fixing Practices within Free/Libre Open Source Software Development Teams - Kevin Crowston; Barbara Scozzi (Journal of Database Management, 2008)
Free/libre open source software (FLOSS, e.g., Linux or Apache) is primarily developed by distributed teams. Developers contribute from around the world and coordinate their activity almost exclusively by means of email and bulletin boards, yet some how profit from the advantages and evade the challenges of distributed software development. In this article we investigate the structure and the coordination practices adopted by development teams during the bug-fixing process, which is considered one of main areas of FLOSS project success. In particular, based on a codification of the messages recorded in the bug tracking system of four projects, we identify the accomplished tasks, the adopted coordination mechanisms, and the role undertaken by both the FLOSS development team and the FLOSS community. We conclude with suggestions for further research.
Keywords: activity; bug tracker; bug tracking system; coordination; downloads; dynapi; effectiveness; FLOSS; gaim; kicq; phpmyadmin; project success; size; status

The business of open source - Watson, R. T.; Boudreau, M. C.; York, P. T.; Greiner, M. E.; Wynn, D. (Communications of the ACM, 2008)

Challenges and strategies in the use of Open Source Software by Independent Software Vendors - Ven, Kris; Mannaert, Herwig (Information and Software Technology, 2008)
Open Source Software (OSS) has already been adopted by a large number of organizations. An important – but sometimes neglected – group of OSS users are Independent Software Vendors (ISVs). ISVs often develop their applications on top of OSS platform software. Frequently, this requires making several extensions and modifications to these OSS components. We identify a number of challenges that ISVs face in handling these extensions and modifications. Next, we describe several strategies ISVs can follow in maintaining these modifications. Finally, we suggest an opportunity for a closer collaboration between OSS projects and ISVs which could be mutually beneficial.
Keywords: Contributing; Independent Software Vendor

Champions of Revealing - The Role of Open Source Developers in Commercial Firms - Joachim Henkel (2008)
The link between firms engaging in open source software (OSS) development and the OSS community is established by individual developers. This linkage might entail a principal-agent issue due to the developer's double allegiance to firm and OSS community, and expose the firm to the risk of losing intellectual property. Using both interviews and a large-scale survey, I substantiate the importance of the developer's role. However, neither interview data nor regression analysis show indications of commercially harmful revealing behavior induced by ""Free Software ideology."" Management, on the other hand, sometimes seems to be overly concerned about openness. I conclude that a more positive stance towards openness will allow firms to better share in the benefits of open innovation processes.

Channeling Firefox Developers: Mom and Dad Aren’t Happy Yet - Jean-Michel Dalle; den Besten, Matthijs; Masmoudi, Héla (OSS2008: Open Source Development, Communities and Quality (IFIP 2.13), 2008)
Firefox, a browser targeted at mainstream users, has been one of the big successes of open source development in recent years. That Firefox succeeded where earlier attempts failed is undoubtedly due to the particular choices that were made in the process of development. In this paper, we look at this process in more detail. Mining bug reports and feature requests related to Firefox in Mozilla’s Bugzilla bug tracker system, we find that the attention developers devoted to reports and requests was influenced by several factors. Most importantly, other things being equal, reports and requests from outsiders increasingly tend to be ignored. While such behavior may have helped to shield Firefox from the “alpha-geek power user” in the early stages of development, it also makes it difficult for “mom and dad” to let their voice be heard even after they have adopted Firefox.

Claiming Copyleft in Open Source Software: What if the Free Software Foundation's General Public License (GPL) had been Patented? - Greg R Vetter (2008)
Patent law, by necessity, needs some way to evaluate inventiveness. Otherwise, it will grant rights to advances not worth ""the embarrassment of an exclusive patent."" The innovations of version two of the Free Software Foundation's (FSF) GNU General Public License (GPLv2), arriving in 1991, could not, under U.S. patent law at that time, have been meaningfully measured against patent law's criteria, often referred to as the five elements of patentability. The first element of patentability, statutory subject matter, would have excluded the GPLv2's copyright-based licensing technique as a ""business method."" A variety of industry developments in the decades following GPLv2's arrival, combined with the license's potent ideological force and clever use of copyright law, propelled FOSS licensing into a prominent and path-breaking place within information technology worldwide. Its force and presence, and lightning-rod character, have grown over time, with GPLv2 remaining the dominant license in mind-share, if not code-share. In addition, all of this occurred without patent protection for GPLv2's unique licensing technique. This then raises the counter-factual inquiry for this symposium article: what might have occurred differently if GPLv2's licensing method had been patentable? In other words, if the U.S. patent law of statutory subject matter in 1991 was sufficiently permissive, and if the FSF and Richard Stallman successfully patented the novel licensing approaches of GPLv2, would patent protection have altered the FOSS movement's two-decade trajectory through information technology and the Internet? If so, can we estimate in what ways? The Article's assessment is that GPLv2 could readily meet the other four elements of patentability (with non-obviousness being the closest call compared to prior sublicensing schemes), and that the FOSS trajectory would change minimally, due to a variety of factors, including practical constraints on the enforcement potency of patent claims to GPLv2, competition from other types of FOSS licensing, and strategic considerations for a variety of players and camps within the FOSS movement. However, in the counterfactual, license proliferation diminishes, and dual licensing may be foreclosed.

Collecting data from distributed FOSS projects - Fagerholm, Fabian; Taina, Juha (3rd Workshop on Public Data about Software Development (WoPDaSD 2008), 2008)
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 eﬀect of highly distributed software development, as found in the Linux kernel project, on collection and modelling of software development data. We ﬁnd 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

Competitive Implications of Software Open-Sourcing - Jai Asundi; Octavian Carare; Kutsal Dogan (2008)
This paper is concerned with the economic trade-offs associated with open-sourcing, the business strategy of releasing free open-source versions of commercial software products. The effect of the release of open-source versions on the customers' perception of products is an important determinant of open-sourcing outcomes. We model open-sourcing as a strategic option for firms that compete in the market for software products. Of particular importance in our model is the effect of open-sourcing on customer values and the possibility for better customization offered by the open-source products. We show that open-sourcing can arise as an equilibrium outcome in our simple two-stage game. If the enhancement of customer values from open-sourcing is moderate or high, firms may find it optimal to release open-source versions of their products.

Computer support for discovering oss processes - Chris Jensen; Walt Scacchi (3rd Workshop on Public Data about Software Development (WoPDaSD 2008), 2008)
Large scale open source software (OSS) projects offer a wide range of documentation of the software processes that have enabled their success. Discovering these processes has been shown to be difficult to achieve. This paper describes our experiences with providing computer support for discovering OSS processes from project data. We discuss challenges of collecting and analyzing data from multiple types of project artifacts and how to address them.
Keywords: artifacts; Firefox; process management; zotero

The confusion of crowds: non-dyadic help interactions - Singh, V; Twidale, M.B (CSCW '08: Proceedings of the 2008 ACM conference on Computer supported cooperative work, 2008)
Help-giving interactions in open source technical support often involve more people than the conventional help-giver help-seeker pair. Contributions include lightweight but useful me-too contributions from fellow help-seekers. Problems with the reuse of help documentation may be resolved by contextualized discussions, and those discussions themselves are found to be substantially reused.
Keywords: help-giving; technical help

Continuous Integration in Open Source Software Development - Amit Deshpande; Dirk Riehle (Fourth International Conference on Open Source Software, 2008)
Commercial software firms are increasingly using and contributing to open source software. Thus, they need to understand and work with open source software development processes. This paper investigates whether the practice of continuous integration of agile software development methods has had an impact on open source software projects. Using fine-granular data from more than 5000 active open source software projects we analyze the size of code contributions over a project's life-span. Code contribution size has stayed flat. We interpret this to mean that open source software development has not changed its code integration practices. In particular, within the limits of this study, we claim that the practice of continuous integration has not yet significantly influenced the behavior of open source software developers.

Continuous Integration in Open Source Software Development - Amit Deshpande; Dirk Riehle (OSS2008: Open Source Development, Communities and Quality (IFIP 2.13), 2008)
Commercial software firms are increasingly using and contributing to open source software. Thus, they need to understand and work with open source software development processes. This paper investigates whether the practice of continuous integration of agile software development methods has had an impact on open source software projects. Using fine-granular data from more than 5000 active open source software projects we analyze the size of code contributions over a project’s life-span. Code contribution size has stayed flat. We interpret this to mean that open source software development has not changed its code integration practices. In particular, within the limits of this study, we claim that the practice of continuous integration has not yet significantly influenced the behavior of open source software developers.

Crafting the initial user experience to achieve community goals - Drenner, S.; Sen, S.; Terveen, L. (ACM Conference on recommender Systems, 2008)

Cross-repository data linking with RDF and OWL - Howison, James (3rd Workshop on Public Data about Software Development (WoPDaSD 2008), 2008)
This paper provides an approach to the problem of integrating data from multiple research repositories for FLOSS data. It introduces semantic web technologies (RDF, OWL, OWL-DL reasoners and SPARQL) to argue that these are useful for building shared research infrastructure. The paper illustrates its point by describing parts of an ontology developed for the integration and analysis of project communications drawn from FLOSSmole, the Notre Dame archive and direct collection of data. RDF vocabularies provide a way to agree on things we agree about as well as a way to be clearer about ways in which we disagree.
Keywords: data integration; flossmole; forges; integration; owl; RDF; repositories; semantic; semantic Web; sparql; srda

Design for quality: The case of Open Source Software Development - Conley, Caryn A. (New York University, 2008)

Detecting Agility of Open Source Projects Through Developer Engagement - Adams, Paul; Capiluppi, Andrea; de Groot, Adriaan (OSS2008: Open Source Development, Communities and Quality (IFIP 2.13), 2008)
The principles behind the agile development methods and common practise within the Open Source community are vastly different. In recent years there has been a rise of interest in these, in order to detect and inform on areas of compatible shared practises. This paper argues that it is possible to quantify the level of agility displayed by Open Source projects. An indicator of agility, the Mean Developer Engagement (MDE) metric is introduced and tested through the analysis of public project data. Projects sampled from two repositories (KDE and SourceForge) are studied and a hypothesis is formulated: projects from the two samples display a similar level of MDE. This paper provides two main contributions: first, the MDE metric is shown to vary significantly between the KDE and SourceForge projects. Second, by combining MDE with a project’s lifespan, it is also shown that SourceForge projects have insufficient uptake of new developers resulting in more active, shorter, initial activity, and in a quicker “burning out” of the projects.

Determinism and evolution - González-Barahona, Jesús M.; Gregorio Robles; Herraiz, Israel (Proceedings of the 2008 international workshop on Mining software repositories - MSR '08, 2008)
It has been proposed that software evolution follows a Self-Organized Criticality (SOC) dynamics. This fact is supported by the presence of long range correlations in the time series of the number of changes made to the source code over time. Those long range correlations imply that the current state of the project was determined time ago. In other words, the evolution of the software project is governed by a sort of determinism. But this idea seems to contradict intuition. To explore this apparent contradiction, we have performed an empirical study on a sample of 3,821 libre (free, open source) software projects, finding that their evolution projects is short range correlated. This suggests that the dynamics of software evolution may not be SOC, and therefore that the past of a project does not determine its future except for relatively short periods of time, at least for libre software.
Keywords: changes; evolution; source code; sourceforge

Developing 'FLOSS' - A Market Driven Investment: First Evidence from a Francophone Companies Survey - Nicolas Jullien (2008)
Over the last few years, FLOSS (""Free Libre Open Source Software"") has become a commercially viable reality of the first order. It is viewed as an extreme case of open innovation (Chesbrough, 2003), and thus of a laboratory for analysing innovation production in Internet based/knowledge based industries. It the FLOSS field an increasing number of companies are getting involved in the communities of development (Lakhani & Wolf 2005). Scholars (see, for instance Dahlander & Wallin 2006) has analysed this as a way to control a complementary asset, without owning it (as defined by Teece 1986, Teece & al. 1997). In this article, we defend the idea that involvement can be of different intensity, from complementary to specific asset, and that this intensity depends of the market of the firm. To do so, we surveyed francophone companies (France, Belgium, Switzerland) affirming a utilization of FLOSS in their commercial activity. Based on roughly 500 companies concerned, we obtained 141 usable responses and, via an ascendant hierarchical clustering (AHC) we statistically verified a link between FLOSS commercial strategies and degree of involvement into communities. We propose a typology of commercial strategies explaining this differences in involvement.

Dynamics of innovation in an "open source" collaboration environment: lurking, laboring, and launching FLOSS projects on SourceForge - David, P. A.; Rullani, F. (Industrial and Corporate Change, 2008)
A systems analysis perspective is adopted to examine the critical properties of the Free/Libre/Open Source Software (FLOSS) mode of innovation, as reflected on the SourceForge platform (SF.net). This approach re-scales March's (1991) framework and applies it to characterize the “innovation system” of a “distributed organization” of interacting agents in a virtual collaboration environment, rather than to innovation within a firm. March (1991) views the process of innovation at the organizational level as the coupling of sub-processes of exploration and exploitation. Correspondingly, the innovation system of the virtual collaboration environment represented by SF.net is an emergent property of two “coupled” processes: one involves the interactions among agents searching the locale for information and knowledge resources to use in designing novel software products (i.e., exploration), and the other involves the mobilization of individuals’ capabilities for application in the software development projects that become established on the platform (i.e., exploitation). The micro-dynamics of this system are studied empirically by constructing transition probability matrices representing the movements of 222,835 SF.net users among seven different activity states, which range from “lurking” (not contributing or contributing to projects without becoming a member) to “laboring” (joining one or more projects as members), and to “launching” (founding one or more projects) within each successive 6-month interval. The estimated probabilities are found to form first-order Markov chains describing ergodic processes. This makes it possible the computation of the equilibrium distribution of agents among the states, thereby suppressing transient effects and revealing persisting patterns of project joining and project launching. The latter show the FLOSS innovation process on SF.net to be highly dissipative: a very large proportion of the registered “developers” fail to become even minimally active on the platform. There is nevertheless an active core of mobile project joiners, and a (still smaller) core of project founders who persist in creating new projects. The structure of these groups’ interactions (as displayed within the 3-year period examined) is investigated in detail, and it is shown that it would be sufficient to sustain both the exploration and exploitation phases of the platform's global dynamics.
Keywords: contributors; core; developers; roles; SFnetDataset; sourceforge; users; virtual communities; virtual organization; virtual organizations

Effort modeling and programmer participation in open source software projects - Koch, Stefan (Information Economics and Policy (Empirical Issues in Open Source Software), 2008)
This paper develops models for programmer participation and effort estimation in open source software projects and employs the results to assess the efficiency of open source software creation. Successful development of such models will be important for decision makers of various kinds. We propose hypotheses based on a prior case study on manpower function and effort modeling. A large data set retrieved from a project repository is used to test these hypotheses. The main results are that if Norden-Rayleigh-based approaches are used, they need to be complemented in order to account for the addition of new features during a product life cycle, and that programmer-participation based effort models result in distinctly lower estimations of effort than those based on output metrics, such as lines of code.
Keywords: cvs; developers; email; email archives; gnome; lines of code; scm; Software repository mining; source code; sourceforge

Emerging Issues in the Acquisition of Open Source Software within the U.S. Department of Defense - Alspaugh, Thomas; Walt Scacchi (5th Annual Acquisition Research Symposium, 2008)

Emerging Patterns of Intersection and Segmentation when Computerization Movements Interact - Walt Scacchi (Computerization Movements and Technology Diffusion: From Mainframes to Ubiquitous Computing, 2008)

Empirical Analysis of the Bug Fixing Process in Open Source Projects - Francalanci, Chiara; Merlo, Francesco (OSS2008: Open Source Development, Communities and Quality (IFIP 2.13), 2008)
Monitoring the performance of processes is often considered critical in classic engineering fields. However, in the area of software engineering (and especially in the Open Source context) it seems that the literature has not yet taken into consideration the problem of identifying the process characteristics and performance of debugging. The aim of this paper is the identification of the performance characteristics of the bug fixing process of Open Source applications, focusing on continuity and efficiency indicators. The importance of such indicators is even more relevant today, since Open Source software is now adopted also in many business contexts. We have analyzed the debugging process of 9 active and popular Open Source projects, collecting a dataset comprising more than 65,000 closed bugs. Results have highlighted four types of bug fixing processes that can be distinguished by considering temporal continuity and efficiency dimensions.

An Empirical Investigation into the Adoption of Open Source Software in Hospitals - Gilberto Munoz; Carolyn Seaman (2008)
Open source software (OSS) has gained considerable attention recently in health care. Yet, how and why OSS is being adopted within hospitals in particular remains a poorly understood issue. This research attempts to further this understanding. A mixed-method research approach was used to explore the extent of OSS adoption in hospitals as well as the factors facilitating and inhibiting adoption. The findings suggest a very limited adoption of OSS in hospitals. Hospitals tend to adopt general-purpose instead of domain-specific OSS. We found that software vendors are the critical factor facilitating the adoption of OSS in hospitals. Conversely, lack of in-house development, as well as a perceived lack of security, quality, and accountability of OSS products were factors inhibiting adoption. An empirical model is presented to illustrate the factors facilitating and inhibiting the adoption of OSS in hospitals.

An Empirical Study on the Relationship Between Software Design Quality, Development Effort and Governance in Open Source Projects - Capra, E.; Francalanci, C.; Merlo, F. (IEEE Transactions on Software Engineering, 2008)
The relationship among software design quality, development effort, and governance practices is a traditional research problem. However, the extent to which consolidated results on this relationship remain valid for open source (OS) projects is an open research problem. An emerging body of literature contrasts the view of open source as an alternative to proprietary software and explains that there exists a continuum between closed and open source projects. This paper hypothesizes that as projects approach the OS end of the continuum, governance becomes less formal. In turn a less formal governance is hypothesized to require a higher-quality code as a means to facilitate coordination among developers by making the structure of code explicit and facilitate quality by removing the pressure of deadlines from contributors. However, a less formal governance is also hypothesized to increase development effort due to a more cumbersome coordination overhead. The verification of research hypotheses is based on empirical data from a sample of 75 major OS projects. Empirical evidence supports our hypotheses and suggests that software quality, mainly measured as coupling and inheritance, does not increase development effort, but represents an important managerial variable to implement the more open governance approach that characterizes OS projects which, in turn, increases development effort.
Keywords: effort estimation; governance; quality; source code

An Empirical Study on the Relationship Between Software Design Quality, Development Effort and Governance in Open Source Projects - Capra, Eugenio; Francalanci, Chiara; Merlo, Francesco (IEEE Transactions on Software Engineering, 2008)
The relationship among software design quality, development effort, and governance practices is a traditional research problem. However, the extent to which consolidated results on this relationship remain valid for open source (OS) projects is an open research problem. An emerging body of literature contrasts the view of open source as an alternative to proprietary software and explains that there exists a continuum between closed and open source projects. This paper hypothesizes that as projects approach the OS end of the continuum, governance becomes less formal. In turn a less formal governance is hypothesized to require a higher-quality code as a means to facilitate coordination among developers by making the structure of code explicit and facilitate quality by removing the pressure of deadlines from contributors. However, a less formal governance is also hypothesized to increase development effort due to a more cumbersome coordination overhead. The verification of research hypotheses is based on empirical data from a sample of 75 major OS projects. Empirical evidence supports our hypotheses and suggests that software quality, mainly measured as coupling and inheritance, does not increase development effort, but represents an important managerial variable to implement the more open governance approach that characterizes OS projects which, in turn, increases development effort.

eResearch Workflows for Studying Free and Open Source Software Development - Howison, James; Andrea Wiggins; Kevin Crowston (OSS2008: Open Source Development, Communities and Quality (IFIP 2.13), 2008)
This paper introduces eResearch workflow tools as a model for the research community studying free and open source software and its development. The paper first introduces eResearch as increasingly practiced in fields such as astrophysics and biology, then contrasts the practice of research on free and open source software. After outlining suitable research data sets the paper introduces a class of tools known as scientific workflow frameworks, focusing on one?Taverna?and introducing its features. To further explain the tool a complete workflow used for original research on FLOSS is described. Finally the paper considers the trade-offs inherent in these tools.

eResearch Workflows for Studying Free and Open Source Software Development - Howison, James; Andrea Wiggins; Kevin Crowston (OSS2008: Open Source Development, Communities and Quality (IFIP 2.13), 2008)
This paper introduces eResearch workflow tools as a model for the research community studying free and open source software and its development. The paper first introduces eResearch as increasingly practiced in fields such as astrophysics and biology,then contrasts the practice of research on free and open source software. After outlining suitable research data sets the paper introduces a class of tools known as scientific workflow frameworks, focusing on one—Taverna—and introducing its features.To further explain the tool a complete workflow used for original research on FLOSS is described. Finally the paper considers the trade-offs inherent in these tools.

eScience for Free/Libre Open Source Software Researchers - Kevin Crowston; Andrea Wiggins; James Howison (FLOSSpapers, 2008)
This paper presents a case study of the application of eScience tools and practices for the social science research community studying Free/Libre Open Source Software (FLOSS) development practices. We first describe what we mean by eScience and introduce research on FLOSS to motivate the need for eScience tools and approaches. We then describe our initial efforts to introduce eScience tools for FLOSS research, potential obstacles, and how the use of such tools might affect the practice of research in this field.

Evaluating the performance of open source software projects using data envelopment analysis - Wray, Barry; Mathieu, Richard; Teets, J. (Information Management & Computer Security, 2008)
Purpose – The purpose of this paper is to develop and test a model of the relative performance of open source software (OSS) projects. Design/methodology/approach – This paper evaluates the relative performance of OSS projects by evaluating multiple project inputs and multiple project outputs by using a data envelopment analysis (DEA) model. The DEA model produces an efficiency score for each project based on project inputs and outputs. The method of producing an efficiency score is based on the convex envelopment technology structure. The efficiency measure quantifies a “distance” to an efficient frontier. Findings – The DEA model produced an index of corresponding intensities linking an inefficient project to its benchmark efficient project(s). The inefficiency measures produced an ordering of inefficient projects. Eight projects were found to be “efficient” and used as benchmarking projects. Research limitations/implications – This research is limited to only security-based OSS projects. Future research on other areas of OSS projects is warranted. Practical implications – The result of this research is a practical model that can be used by OSS project developers to evaluate the relative performance of their projects and make resource decisions. Originality/value – This research extends the work of previous studies that have examined the relative performance of software development projects in a traditional development environment. As a result of this research, OSS projects can now be adequately benchmarked and evaluated according to project performance. An OSS project manger can effectively use these results to critically evaluate resources for their project and judge the relative efficiency of the resources.
Keywords: dea; efficiency; Project performance; sourceforge

Evaluating the Quality of Open Source Software - Diomidis Spinellis; Gousios, Georgios; Vassilios Karakoidas; Panagiotis Louridas; Paul J. Adams; Samoladas, Ioannis; Ioannis Stamelos (Electronic Notes in Theoretical Computer Science, 2008)
Traditionally, research on quality attributes was either kept under wraps within the organization that performed it, or carried out by outsiders using narrow, black-box techniques. The emergence of open source software has changed this picture allowing us to evaluate both software products and the processes that yield them. Thus, the software source code and the associated data stored in the version control system, the bug tracking databases, the mailing lists, and the wikis allow us to evaluate quality in a transparent way. Even better, the large number of (often competing) open source projects makes it possible to contrast the quality of comparable systems serving the same domain. Furthermore, by combining historical source code snapshots with significant events, such as bug discoveries and fixes, we can further dig into the causes and effects of problems. Here we present motivating examples, tools, and techniques that can be used to evaluate the quality of open source (and by extension also proprietary) software.
Keywords: bug tracking system; email; email archives; mailing list; metrics; open source; process quality attributes; product quality attributes; source code; SQO-OSS; wiki

Evaluation of source code copy detection methods on freebsd - Chang, Hung-Fu; Audris Mockus (Proceedings of the 2008 international working conference on Mining software repositories, 2008)
Studies have shown that substantial code reuse is common in open source and in commercial projects. However, the precise extent of reuse and its impact on productivity and quality are not well investigated in the open source context. Previously, we have introduced a simple-to-use method that needs only a set of file pathnames to identifies directories that share filenames and partially validated its performance on a set of closed-source projects. To evaluate this method and to improve reuse detection at the file level, we apply it and four additional file copy detection methods that utilize the underlying content of multiple versions of the source code on the FreeBSD project. The evaluation quantified unique advantages of each method and showed that the filename method detected roughly half of all reuse cases. We are still faced with a challenge to scale the content based methods to large repositories containing all versions of open source files.
Keywords: clone; cloning; code copying; freebsd; version control

Expertise identification and visualization from CVS - Alonso, Omar; Premkumar T. Devanbu; Gertz, Michael (Proceedings of the 2008 international working conference on Mining software repositories, 2008)
As software evolves over time, the identification of expertise becomes an important problem. Component ownership and team awareness of such ownership are signals of solid project. Ownership and ownership awareness are also issues in open-source software (OSS) projects. Indeed, the membership in OSS projects is dynamic with team members arriving and leaving. In large open source projects, specialists who know the system very well are considered experts. How can one identify the experts in a project by mining a particular repository like the source code? Have they gotten help from other people? We provide an approach using classification of the source code tree as a path to derive the expertise of the committers. Because committers may get help from other people, we also retrieve their contributors. We also provide a visualization that helps to further explore the repository via committers and categories. We present a prototype implementation that describes our research using the Apache HTTP Web server project as a case study.
Keywords: apache; classification; committers; components; contributors; expertise; expertise identification; repository; scm; source code

Explaining leadership in virtual teams: The case of open source software - Paola Giuri; Francesco Rullani; Salvatore Torrisi (Information Economics and Policy, 2008)
This paper contributes to the open source software (OSS) literature by investigating the likelihood that a participant becomes a project leader. Project leaders are key actors in a virtual community and are crucial to the success of the OSS model. Knowledge of the forces that lead to the emergence of project managers among the multitude of participants is still limited. We aim to fill this gap in the literature by analyzing the association between the roles played by an individual who is registered with a project, and a set of individual-level and project-level characteristics. In line with the theory of occupational choice elaborated by (Lazear, E.P., 2002. Entrepreneurship. NBER Working Paper No. 9109, Cambridge, Mass; Lazear, E.P., 2004. Balanced skills and entrepreneurship, American Economic Review 94, pp. 208-211), we find that OSS project leaders possess diversified skill sets which are needed to select the inputs provided by various participants, motivate contributors, and coordinate their efforts. Specialists, like pure developers, are endowed with more focused skill sets. Moreover, we find that the degree of modularity of the development process is positively associated with the presence of project leaders. That result is consistent with the modern theory of modular production (Baldwin, C.Y., Clark, K.B., 1997. Managing in an age of modularity. Harvard Business Review September-October. pp. 84-93; Mateos-Garcia, J., Steinmueller, W.E., 2003. The Open Source Way of Working: A New Paradigm for the Division of Labour in Software Development? SPRU - Science and Technology Policy Studies. Open Source Movement Research INK Working Paper, No. 1; Aoki, M., 2004. An organizational architecture of T-form: Silicon Valley clustering and its institutional coherence. Industrial and Corporate Change 13, pp. 967-981).
Keywords: contributors; Human capital; leadership; roles; sourceforge; team

An Exploratory Study on the Evolution of OSS Developer Communities - Ngamkajornwiwat, Kawin; Zhang, Dongsong; Koru, A. Gunes; Zhou, Lina; Nolker, and Robert (Proceedings of the 41st Annual Hawaii International Conference on System Sciences (HICSS 2008), 2008)
Software is developed in a dynamic context where team structure, requirements, and processes evolve together with the product. Although researchers have been studying the evolution of software systems since the early 70s, the study on the evolution of software development teams remains rare. Such evolutionary patterns and their impact on software quality are especially important in the context of OSS (Open Source Software) development, where a group of volunteer developers collaborate online for an extended period of time. By analyzing how social networks of developers evolve over time while building OSS products, we can gain knowledge and experience to improve the effectiveness and efficiency of resource management and distribution in future OSS projects. To this end, we studied the evolution of the developer communities using a suite of OSS products developed under the KOffice project. We found that in general, the social networks of OSS developer communities change over time in certain ways. Identifying such patterns can help OSS managers better understand the unique process of OSS development and improve their management and coordination of the projects.

An extension of fault-prone filtering using precise training and a dynamic threshold - Hata, Hideaki; Mizuno, Osamu; Kikuno, Tohru (Proceedings of the 2008 international working conference on Mining software repositories, 2008)
Fault-prone module detection in source code is important for assurance of software quality. Most previous fault-prone detection approaches have been based on software metrics. Such approaches, however, have difficulties in collecting the metrics and in constructing mathematical models based on the metrics. To mitigate such difficulties, we have proposed a novel approach for detecting fault-prone modules using a spam-filtering technique, named Fault-Prone Filtering. In our approach, fault-prone modules are detected in such a way that the source code modules are considered as text files and are applied to the spam filter directly. In practice, we use the training only errors procedure and apply this procedure to fault-prone. Since no pre-training is required, this procedure can be applied to an actual development field immediately. This paper describes an extension of the training only errors procedures. We introduce a precise unit of training, "modified lines of code," instead of methods. In addition, we introduce the dynamic threshold for classification. The result of the experiment shows that our extension leads to twice the precision with about the same recall, and improves 15% on the best F1 measurement.
Keywords: eclipse; fault-prone modules; spam filter; text mining

Extracting Generally Applicable Patterns from Object-Oriented Programs for the Purpose of Test Case Creation - Torkar, Richard; Feldt, Robert; Gorschek, Tony (OSS2008: Open Source Development, Communities and Quality (IFIP 2.13), 2008)
This paper presents an experiment performed on three large open source applications. The applications were instrumented automatically with a total of 10,494 instrumentation points. The purpose of the instrumentation was to collect and store data during the execution of each application that later could be analyzed off-line. Data analysis, on the collected data, allowed for the creation of test cases (test data, test fixtures and test evaluators) in addition to finding object message patterns for object-oriented software.

Extracting structural information from bug reports - Premraj, Rahul; Zimmermann, Thomas; Kim, Sunghun; Bettenburg, Nicolas (Proceedings of the 2008 international workshop on Mining software repositories - MSR '08, 2008)
In software engineering experiments, the description of bug reports is typically treated as natural language text, although it often contains stack traces, source code, and patches. Neglecting such structural elements is a loss of valuable information; structure usually leads to a better performance of machine learning approaches. In this paper, we present a tool called infoZilla that detects structural elements from bug reports with near perfect accuracy and allows us to extract them. We anticipate that infoZilla can be used to leverage data from bug reports at a different granularity level that can facilitate interesting research in the future.
Keywords: bug reports; eclipse; enumerations; infozilla; natural language; patches; source code; stack trace

Facilitating Social Network Studies of FLOSS using the OSSNetwork Environment - Balieiro, Marco; de Júnior, Samuel; De Souza, Cleidson (OSS2008: Open Source Development, Communities and Quality (IFIP 2.13), 2008)
Open source projects are typical examples of successful distributed software development projects. Understanding how coordination in these projects takes place can provide important lessons to Software Engineering researchers and practitioners. This understanding has been achieved using different research methods, including, surveys, case studies and social network analysis. However, to conduct these studies each researcher needs to build his own infra-structure from the scratch, a time consuming and error-prone task. This paper aims to alleviate this problem by describing an environment, the OSSNetwork, which allows the automatic data collection of open source repositories. Data collected by the OSSNetwork is aimed to support the construction, visualization, and analysis of social networks. This environment is extensible, therefore facilitating empirical studies of open source projects.

FLOSS-like education transfer report - Andreas Meiszner (2008)
Free/Libre and Open Source Software (FLOSS) communities are not only an exemplar for successful software development, but also for well working learning environments. Yet little is known about how learning occurs in the FLOSS communities and what the underlying success factors are. FLOSS communities might be seen as an example of 'Best Practice' in how ICT can help to improve education in terms of learning processes, up to date content and open inclusive education where no learner is excluded from participation.The FLOSSCOM project was undertaken in order to evaluate how learning in FLOSS is organised and if, to which degree, and how FLOSS learning principles can be transferred to and used for the improvement of ICT supported formal education. Precisely, the FLOSSPOLS project intended to- identify the factors that contribute to successful knowledge construction in informal learning communities, such as the FLOSS communities- analyze the effectiveness of a FLOSS-like learning community in a formal educational setting- provide case studies, scenarios and guidelines for teachers and decision-makers on how to successfully embed such learning communities within formal educational environments to enhance student progression, retention and achievement- evaluate the project and disseminate the results to the wider community.This report is the third and final report of the FLOSSCOM project. It aims to provide scenarios and guidelines for teachers and decision-makers as practical documentation on how principles of FLOSS-like informal learning communities might be transferred to formal educational environments.

Forging A Community – Not: Experiences On Establishing An Open Source Project - Järvensivu, Juha; Mikkonen, Tommi (OSS2008: Open Source Development, Communities and Quality (IFIP 2.13), 2008)
Open source has recently become a practical and advocated fashion to develop, integrate, and license software. As a consequence, open source communities that commonly perform the development work are becoming important in the practice of software engineering. A community that is lively can often produce high-quality systems that continuously grow in terms of features, whereas communities that do not gain interest will inevitably perish. Despite their newly established central role, creation, organization, and management of such communities have not yet been widely studied from the viewpoint of software engineering practices. In this paper, we discuss experiences gained in the scope of Laika, an open source project established to develop an integrated software development environment for developing applications that run in Linux based mobile devices.

The FOSSology project - Gobeille, Robert (Proceedings of the 2008 international working conference on Mining software repositories, 2008)
By its nature, the availability of FOSS has given computer scientists a large body of software and software projects to analyze. By having available source, version control system metadata, and open project communities, much can be learned about a software project, software development and collaborative project development. The goal of the FOSSology project is to create a public, open source software repository, together with tools to facilitate analysis, storage, and sharing of open source software and its metadata. FOSSology does license detection today.
Keywords: abiword; fossology; license analysis; licenses

The Foundations of Openness - Pia Waugh; Randy Metcalfe (2008)
This project explores the notion of openness in software projects. It contextualizes different facets of openness and considers their individual and collective usefulness. It provides a tentative evaluative schema to allow others to weigh up specific criteria that may be important to them. It acknowledges that these criteria may have different weightings for different people, e.g. governance vs open standards vs code licence. The object is *not* a blanket recommendation for openness in all facets of a project. Rather it is a tool for projects, and those who use those projects, to investigate and illuminate the choices being made as well as the implication of open and closed approaches.

A Framework for Evaluating Managerial Styles in Open Source Projects - Capra, Eugenio; Wasserman, Anthony (OSS2008: Open Source Development, Communities and Quality (IFIP 2.13), 2008)
This paper presents the Software Project Governance Framework (SPGF) for characterizing management of software projects, based on mechanisms used for communication and collaboration, the organizational structure of projects, and testing and quality assurance procedures. The framework was developed and validated from interviews and surveys with leaders of more than 70 commercial and community-based software projects, including both closed and open source projects.