Article

Code Reuse in Open Source Software

Authors:
To read the full-text of this research, you can request a copy directly from the authors.

Abstract

Code reuse is a form of knowledge reuse in software development, which is fundamental to innovation in many fields. To date, there has been no systematic investigation of code reuse in open source software projects. This study uses quantitative and qualitative data gathered from a sample of six open source software projects, to evaluate two sets of propositions derived from the literature on software reuse in firms and open source software development. We find that code reuse is extensive across the sample and that open source software developers, much like developers in firms, apply tools that lower their search costs for knowledge and code, assess the quality of software components, and they have incentives to reuse code. Open source software developers reuse code because they want to integrate functionality quickly, because they want to write preferred code, because they operate under limited resources in terms of time and skills, and because they can mitigate development costs through code reuse. I

No full-text available

Request Full-text Paper PDF

To read the full-text of this research,
you can request a copy directly from the authors.

... Moreover, existing studies, e.g. Haefliger et al. (2008), Kawamitsu et al. (2014), Feitosa et al. (2020), andvon Krogh et al. (2005) only focus on between 10 and a few hundred projects. For this study, we examined 22,183 hackathon projects, which makes it reasonable to assume that insights from this study -despite them being drawn from hackathon projects only and being focused on reuse at the blob level (i.e. ...
... Code reuse has been a topic of interest and is generally perceived to foster developer effectiveness, efficiency, and reduce development costs (Sojer and Henkel 2010;Haefliger et al. 2008;Feitosa et al. 2020). Existing work so far mainly focuses on the relationship between certain developer traits (Haefliger et al. 2008;Sojer and Henkel 2010;von Krogh et al. 2005) and team and project characteristics such as team size, developer experience, and project size and code reuse (Abdalkareem et al. 2017). ...
... Code reuse has been a topic of interest and is generally perceived to foster developer effectiveness, efficiency, and reduce development costs (Sojer and Henkel 2010;Haefliger et al. 2008;Feitosa et al. 2020). Existing work so far mainly focuses on the relationship between certain developer traits (Haefliger et al. 2008;Sojer and Henkel 2010;von Krogh et al. 2005) and team and project characteristics such as team size, developer experience, and project size and code reuse (Abdalkareem et al. 2017). Moreover, the aforementioned findings are mainly based on surveys among developers, thus covering their perception rather than actual reuse behavior. ...
Article
Full-text available
Context Hackathons have become popular events for teams to collaborate on projects and develop software prototypes. Most existing research focuses on activities during an event with limited attention to the evolution of the hackathon code. Objective We aim to understand the evolution of code used in and created during hackathon events, with a particular focus on the code blobs, specifically, how frequently hackathon teams reuse pre-existing code, how much new code they develop, if that code gets reused afterwards, and what factors affect reuse. Method We collected information about 22,183 hackathon projects from Devpost and obtained related code blobs, authors, project characteristics, original author, code creation time, language, and size information from World of Code. We tracked the reuse of code blobs by identifying all commits containing blobs created during hackathons and identifying all projects that contain those commits. We also conducted a series of surveys in order to gain a deeper understanding of hackathon code evolution that we sent out to hackathon participants whose code was reused, whose code was not reused, and developers who reused some hackathon code. Result 9.14% of the code blobs in hackathon repositories and 8% of the lines of code (LOC) are created during hackathons and around a third of the hackathon code gets reused in other projects by both blob count and LOC. The number of associated technologies and the number of participants in hackathons increase reuse probability. Conclusion The results of our study demonstrates hackathons are not always “one-off” events as the common knowledge dictates and it can serve as a starting point for further studies in this area.
... development cycles [20,69], improved quality and performance [47,50,125], and more time for creation and innovation [59,84,85,125]. There have been various commercial and research information gathering and sensemaking systems that help people with creating reusable knowledge by helping with capturing [16,23,73], organizing [29,51,52], disseminating [32,76,102], and understanding [29,62,91,92,100] information. ...
... Such a framework could be helpful for driving research studying and augmenting reuse across a variety of domains and forms. Here we take a step towards such a framework, starting with knowledge artifacts in the form of comparison tables, which are widely used, and in the domain of programming, where knowledge reuse happens frequently [27,50,54,57,67,70,83,102,115,115]. In the following sections, we discuss three of the most relevant threads of research as they relate to judgements of knowledge reuse. ...
... The practice of knowledge reuse has been particularly relevant in the software industry [50]. Code reuse, in particular, has become a hugely successful paradigm in the development of new software products and services in both the commercial and open source sector. ...
Preprint
Full-text available
As the amount of information online continues to grow, a correspondingly important opportunity is for individuals to reuse knowledge which has been summarized by others rather than starting from scratch. However, appropriate reuse requires judging the relevance, trustworthiness, and thoroughness of others' knowledge in relation to an individual's goals and context. In this work, we explore augmenting judgements of the appropriateness of reusing knowledge in the domain of programming, specifically of reusing artifacts that result from other developers' searching and decision making. Through an analysis of prior research on sensemaking and trust, along with new interviews with developers, we synthesized a framework for reuse judgements. The interviews also validated that developers express a desire for help with judging whether to reuse an existing decision. From this framework, we developed a set of techniques for capturing the initial decision maker's behavior and visualizing signals calculated based on the behavior, to facilitate subsequent consumers' reuse decisions, instantiated in a prototype system called Strata. Results of a user study suggest that the system significantly improves the accuracy, depth, and speed of reusing decisions. These results have implications for systems involving user-generated content in which other users need to evaluate the relevance and trustworthiness of that content.
... They measure whether knowledge has been immediately reused, thus they are more closely related to the basic meaning of reuse. Examples of these more direct forms are software code reuse (Haefliger, von Krogh, and Spaeth, 2008) and the reuse of digital representations of 3D-printing objects (Kyriakou et al., 2017). Also, the reuse of plasmids to replicate them or derive decedents can be seen as a relatively direct form of reuse. ...
... This information determines functionality. It is also easily replicable and reusable (Haefliger et al., 2008), though this is more difficult in the case of plasmids, which need to be physically stored by freezing (Marx, 2014). ...
... Beyond our contributions to the team diversity literature, we introduce the context of plasmid creation and exchange to the literature of innovation management. This context resembles the innovation and sharing activities in open source software and other open knowledge exchange systems (e.g., Haefliger et al., 2008). Thus, it provides the opportunity to test and further develop theory about open knowledge exchange. ...
Article
Innovation increasingly relies on collaboration in teams instead of individual efforts. Although the advantages of teams for innovating are virtually undisputed, we have only a very rudimentary understanding of their success drivers. To shed more light on innovation teams, we conceptualize multiplicity in expertise as nonredundant expertise and distinguish it from factors that facilitate or hinder the integration of this expertise. These factors are overlap in expertise, disparity in team members’ status, and whether or not teams use automation technology. We use the empirical context of molecular biology, especially the part of this field in which teams produce and exchange genetic material in the form of so-called plasmids. Combining data about plasmids from a central plasmid repository (AddGene) with bibliometric data endows us with a rich dataset capturing information about team diversity in addition to two innovation performance measures (the number of plasmid orders and the number of citations attracted by publications). Our analysis shows that multiplicity in expertise increases innovation performance; this relationship is strengthened by the overlap in expertise and weakened by disparity in status and the use of the automation technology. Our paper provides a more detailed theory of expertise diversity and contributes to the diversity literature. Our findings also lead to implications for practitioners.
... Moreover, existing studies, e.g. [28], [29], [30], [31] only focus on between 10 and a few hundred projects. For this study, we examined 22,183 hackathon projects, which makes it reasonable to assume that insights from this study -despite them being drawn from hackathon projects only -would add to the existing knowledge about code reuse in general. ...
... Code reuse has been a topic of interest and is generally perceived to foster developer effectiveness, efficiency, and reduce development costs [40], [28], [30]. Existing work so far mainly focuses on the relationship between certain developer traits [28], [40], [31] and team and project characteristics such as team size, developer experience, and project size and code reuse [41]. ...
... Code reuse has been a topic of interest and is generally perceived to foster developer effectiveness, efficiency, and reduce development costs [40], [28], [30]. Existing work so far mainly focuses on the relationship between certain developer traits [28], [40], [31] and team and project characteristics such as team size, developer experience, and project size and code reuse [41]. Moreover, the aforementioned findings are mainly based on surveys among developers, thus covering their perception rather than actual reuse behavior. ...
Conference Paper
Full-text available
Background: Hackathons have become popular events for teams to collaborate on projects and develop software prototypes. Most existing research focuses on activities during an event with limited attention to the evolution of the code brought to or created during a hackathon. Aim: We aim to understand the evolution of hackathon-related code, specifically, how much hackathon teams rely on pre-existing code or how much new code they develop during a hackathon. Moreover, we aim to understand if and where that code gets reused, and what factors affect reuse. Method: We collected information about 22,183 hackathon projects from DEVPOST– a hackathon database – and obtained related code (blobs), authors, and project characteristics from the WORLD OF CODE. We investigated if code blobs in hackathon projects were created before, during, or after an event by identifying the original blob creation date and author, and also checked if the original author was a hackathon project member. We tracked code reuse by first identifying all commits containing blobs created during an event before determining all projects that contain those commits. Result: While only approximately 9.14% of the code blobs are created during hackathons, this amount is still significant considering time and member constraints of such events. Approximately a third of these code blobs get reused in other projects. The number of associated technologies and the number of participants in a project increase reuse probability. Conclusion: Our study demonstrates to what extent pre-existing code is used and new code is created during a hackathon and how much of it is reused elsewhere afterwards. Our findings help to better understand code reuse as a phenomenon and the role of hackathons in this context and can serve as a starting point for further studies in this area.
... development cycles [20,69], improved quality and performance [47,50,125], and more time for creation and innovation [59,84,85,125]. There have been various commercial and research information gathering and sensemaking systems that help people with creating reusable knowledge by helping with capturing [16,23,73], organizing [29,51,52], disseminating [32,76,102], and understanding [29,62,91,92,100] information. ...
... Such a framework could be helpful for driving research studying and augmenting reuse across a variety of domains and forms. Here we take a step towards such a framework, starting with knowledge artifacts in the form of comparison tables, which are widely used, and in the domain of programming, where knowledge reuse happens frequently [27,50,54,57,67,70,83,102,115,115]. In the following sections, we discuss three of the most relevant threads of research as they relate to judgements of knowledge reuse. ...
... The practice of knowledge reuse has been particularly relevant in the software industry [50]. Code reuse, in particular, has become a hugely successful paradigm in the development of new software products and services in both the commercial and open source sector. ...
Article
Full-text available
As the amount of information online continues to grow, a correspondingly important opportunity is for individuals to reuse knowledge which has been summarized by others rather than starting from scratch. However, appropriate reuse requires judging the relevance, trustworthiness, and thoroughness of others' knowledge in relation to an individual's goals and context. In this work, we explore augmenting judgements of the appropriateness of reusing knowledge in the domain of programming, specifically of reusing artifacts that result from other developers' searching and decision making. Through an analysis of prior research on sensemaking and trust, along with new interviews with developers, we synthesized a framework for reuse judgements. The interviews also validated that developers express a desire for help with judging whether to reuse an existing decision. From this framework, we developed a set of techniques for capturing the initial decision maker's behavior and visualizing signals calculated based on the behavior, to facilitate subsequent consumers' reuse decisions, instantiated in a prototype system called Strata. Results of a user study suggest that the system significantly improves the accuracy, depth, and speed of reusing decisions. These results have implications for systems involving user-generated content in which other users need to evaluate the relevance and trustworthiness of that content.
... Moreover, existing studies, e.g. [28], [29], [30], [31] only focus on between 10 and a few hundred projects. For this study, we examined 22,183 hackathon projects, which makes it reasonable to assume that insights from this study -despite them being drawn from hackathon projects only -would add to the existing knowledge about code reuse in general. ...
... Code reuse has been a topic of interest and is generally perceived to foster developer effectiveness, efficiency, and reduce development costs [40], [28], [30]. Existing work so far mainly focuses on the relationship of certain developer traits [28], [40], [31] and on team and project characteristics such as team size, developer experience, and project size on code reuse [41]. ...
... Code reuse has been a topic of interest and is generally perceived to foster developer effectiveness, efficiency, and reduce development costs [40], [28], [30]. Existing work so far mainly focuses on the relationship of certain developer traits [28], [40], [31] and on team and project characteristics such as team size, developer experience, and project size on code reuse [41]. Moreover, the aforementioned findings are mainly based on surveys among developers, thus covering their perception rather than actual reuse behavior. ...
Preprint
Full-text available
Background: Hackathons have become popular events for teams to collaborate on projects and develop software prototypes. Most existing research focuses on the activities of the event with limited attention to the evolution of the code brought to or created in a hackathon. Aim: We aim to understand the evolution of hackathon-related code, specifically, how much hackathon teams rely on pre-existing code or on new code developed during a hackathon, if and where that code gets reused, and what factors affect hackathon code reuse. Method: We collected information for 22,183 hackathon projects from DevPost - a hackathon database - and obtained the code (blobs), authors, and project characteristics from the World of Code. We investigated if the code blobs in hackathon projects were created before, during, or after the event by identifying the original blob creation date and author, and also checked if the original author was a hackathon project member. We tracked code reuse by first identifying all commits containing the hackathon-created blobs created during the event and then determining all projects with those commits. Result: While only approximately 9.14% of the code blobs are created during the hackathons, this amount is significant considering the time and member constraints. Approximately a third of such code blobs get reused in other projects. The number of associated technologies and the number of participants in a project increase the code reuse probability. Conclusion: Our study demonstrates to what extent pre-existing code is reused and new code is created during a hackathon and how much of it is reused elsewhere. Our findings help to better understand code reuse as a phenomenon and the role of hackathons in this context and can serve as a starting point for further studies in this area.
... Moreover, existing studies, e.g. [21,27,35,38] only focus on between 10 and a few hundred projects. For this study, we examined 22,183 hackathon projects, which makes it reasonable to assume that insights from this study -despite them being drawn from hackathon projects only and being focused on reuse at the blob level (i.e. ...
... Code reuse has been a topic of interest and is generally perceived to foster developer effectiveness, efficiency, and reduce development costs [21,27,60]. Existing work so far mainly focuses on the relationship between certain developer traits [27,38,60] and team and project characteristics such as team size, developer experience, and project size and code reuse [1]. ...
... Code reuse has been a topic of interest and is generally perceived to foster developer effectiveness, efficiency, and reduce development costs [21,27,60]. Existing work so far mainly focuses on the relationship between certain developer traits [27,38,60] and team and project characteristics such as team size, developer experience, and project size and code reuse [1]. Moreover, the aforementioned findings are mainly based on surveys among developers, thus covering their perception rather than actual reuse behavior. ...
Preprint
Full-text available
Background: Hackathons have become popular events for teams to collaborate on projects and develop software prototypes. Most existing research focuses on activities during an event with limited attention to the evolution of the hackathon code. Aim: We aim to understand the evolution of code used in and created during hackathon events, with a particular focus on the code blobs, specifically, how frequently hackathon teams reuse pre-existing code, how much new code they develop, if that code gets reused afterward, and what factors affect reuse. Method: We collected information about 22,183 hackathon projects from DevPost and obtained related code blobs, authors, project characteristics, original author, code creation time, language, and size information from World of Code. We tracked the reuse of code blobs by identifying all commits containing blobs created during hackathons and identifying all projects that contain those commits. We also conducted a series of surveys in order to gain a deeper understanding of hackathon code evolution that we sent out to hackathon participants whose code was reused, whose code was not reused, and developers who reused some hackathon code. Result: 9.14% of the code blobs in hackathon repositories and 8% of the lines of code (LOC) are created during hackathons and around a third of the hackathon code gets reused in other projects by both blob count and LOC. The number of associated technologies and the number of participants in hackathons increase the reuse probability. Conclusion: The results of our study demonstrate hackathons are not always "one-off" events as common knowledge dictates and they can serve as a starting point for further studies in this area.
... Besides these benefits, this design also brings one more big advantage-future features can be added to RALSA more consistently, and much faster, compared to the common practice of writing new functionality from scratch. The implementation of generic components may require an investment, which can pay off in the long run through their reuse, which, in turn, enhances the quality of products by using fully tested and debugged software [37]. The advantages of this approach will allow RALSA to grow in the future, adding more studies using complex sampling and assessment designs, as well as more analysis types, by reusing common objects and functions. ...
... The motivation to develop, adapt, and reuse code, however, can go beyond one's own needs [28], that is, code can be developed and shared with the rest of the software developers for subsequent reuse in other software projects. At the end, "Code reuse is a form of knowledge reuse in software development, which is fundamental to innovation in many fields" [37] (p. 180). ...
Article
Full-text available
International large-scale assessments (ILSAs) provide invaluable information for researchers and policy makers. Analysis of their data, however, requires methods that go beyond the usual analysis techniques assuming simple random sampling. Several software packages that serve this purpose are available. One such is the R Analyzer for Large-Scale Assessments (RALSA), a newly developed R package. The package can work with data from a large number of ILSAs. It was designed for user experience and is suitable for analysts who lack technical expertise and/or familiarity with the R programming language and statistical software. This paper presents the technical aspects of RALSA—the overall design and structure of the package, its internal organization, and the structure of the analysis and data preparation functions. The use of the data.table package for memory efficiency, speed, and embedded computations is explained through examples. The central aspect of the paper is the utilization of code reuse practices to the achieve consistency, efficiency, and safety of the computations performed by the analysis functions of the package. The comprehensive output system to produce multi-sheet MS Excel workbooks is presented and its workflow explained. The paper also explains how the graphical user interface is constructed and how it is linked to the data preparation and analysis functions available in the package.
... Software developers reuse software and code for improving development efficiency, productivity and increase development tempo so that systems can be delivered on time, with lower costs and improved quality and system reliability. This is possible because reused code is often well tested, debugged and documented, making it easier to develop bigger and more complex, yet maintainable systems [1], [2], [9], [12]. ...
... If the person programming does not understand the code being reused, and for efficient reuse they are not always required to, the reused code may impact the complete program negatively [1]. When considering code reuse in a learning context, it is important to underline that code reuse is not only "about the reuse of code per se, but the reuse of human problem-solving" [12]. ...
... Already in early 90s, Chidamber and Kemerer [12] included the Depth of Inheritance Tree (DIT), i.e., a metric that measures the number of classes that inherit from another class, in their Object-Oriented metrics suite. Later on, several other metrics capturing various aspects of inheritance [13], [14], [15] and delegation [16], [17], [18] were proposed, along with best and bad practices on how to use reusability mechanisms [19], [20], [21], [22]. On the empirical standpoint, a noticeable amount of investigations targeted the role of inheritance and delegation in keeping source code quality under control. ...
... Source code reusability has been the subject of several researches in the last decades. These touched various angles of the problem, by introducing novel metrics to capture inheritance relations [12], [13], [14], [15] and delegation [16], [17], [18], defining best design practices to exploit the benefits of reusability [19], [20], or identifying a number of source code quality issues that reusability can cause, e.g., code smells [21], [22], [50]. While the scope of our work targets inheritance and delegation mechanisms, it is worth mentioning the existence of close research areas such as the analysis of design patterns [51], [52] and third-party libraries [53]. ...
Preprint
Full-text available
Context. Software reusability mechanisms, like inheritance and delegation in Object-Oriented programming, are widely recognized as key instruments of software design. These are used to reduce the risks of source code being affected by defects, other than to reduce the effort required to maintain and evolve source code. Previous work has traditionally employed source code reuse metrics for prediction purposes, e.g., in the context of defect prediction. Objective. However, our research identifies two noticeable limitations of current literature. First, still little is known on the extent to which developers actually employ code reuse mechanisms over time. Second, it is still unclear how these mechanisms may contribute to explain defect-proneness and maintenance effort during software evolution. We aim at bridging this gap of knowledge, as an improved understanding of these aspects might provide insights into the actual support provided by these mechanisms, e.g., by suggesting whether and how to use them for prediction purposes. Method. We propose an exploratory study aiming at (1) assessing how developers use inheritance and delegation during software evolution; and (2) statistically analyze the impact of inheritance and delegation on fault proneness and maintenance effort. The study will be conducted on the commits of 17 Java projects of the DEFECTS4J dataset.
... Research discusses successful community innovations in resource-scarce environments (Frazer et al., 2020;Majchrzak & Shepherd, 2021;Richterich, 2020), as well as community engagement in bricolage activities. One example is the regular reuse of knowledge and code (e.g., Faraj et al., 2016;Haefliger, von Krogh, & Spaeth, 2008;Raymond, 1999;Stanko, 2016), whereby "participants [often] retrieve available [knowledge] elements (e.g., previous posts, FAQ documents) and recombine them to fit their immediate needs" (Faraj et al., 2016, p. 7). Likewise, studies on communities provide evidence for the potential value of various bricolage forms of resource development, for example, individual bricolage by Linus Torvalds, who reused "code and ideas from Minix, a tiny Unix-like OS for 386 machines. ...
... This paper makes two contributions to bricolage studies. First, it supports emerging findings about community engagement in bricolage (Faraj et al., 2016;Haefliger et al., 2008;Raymond, 1999;Stanko, 2016) and contributes to undertheorized knowledge about specificities of bricolage within community settings. Studying bricolage within communities, which are highly fluid and evolving organizational settings (Faraj et al.2011), demonstrates the coexistence of different forms of bricolage repertoire creation, and shows that bricolage and its processes evolve as organizational context changes (see Fig. 7). ...
Article
50 days' free access link by Elsevier: https://authors.elsevier.com/a/1dbZS5Ef7AEQzu Peer-production communities can create great value and foster innovation for their members, even in situations where resources are extremely scarce. How these communities create or acquire necessary resources in such settings is an important theoretical and practical question. In this paper, I investigate how a peer-production community overcame substantial resource challenges, using the analytic lens of bricolage theory, in a longitudinal study of HomeNets, communities of residents that developed residential Internet infrastructures and services for a million users in Minsk, Belarus, without funds, material resources, knowledge, or formal legal status. The findings illustrate that communities develop their missing resources by engaging in multiple coexisting bricolage forms and processes, which help them to successfully incorporate the individual and collective resource building efforts of their participants and address the challenges specific to the continuously evolving community. Based on the findings, I propose a model of community resource development with bricolage, discuss theoretical and practical implications for studies on communities and bricolage, and suggest areas for further research.
... The number of vulnerabilities submitted to the Common Vulnerabilities and Exposures (CVE) database is increasing every year e.g., 6,457 in 2016 and almost triple to 18,377 in 2020 [2]. Due to the reuse of open-source software [3], vulnerabilities spread among different projects, firmware, and systems widely [4]. To detect such vulnerabilities, binary function matching techniques are proposed to retrieve vulnerable functions [5]- [11]. ...
... Then PMatch leverages an unsupervised sentence embedding approach to generate semantic feature vectors of patch-affected code snippets and candidate different blocks respectively. ( 2 ), and calculating semantic similarity ( 3 ). The src denotes source code, and bin denotes binary. ...
... Second, we highlight how knowledge reuse, defined as the application of previously created knowledge to solve a current problem (see, e.g., [30], [31]), and boundary spanning, defined as a set of activities performed by individuals to integrate knowledge across contexts (e.g., [32], [33]), are distinct microlevel behaviors underpinning convergence. Knowledge reuse and boundary spanning are important indicators and "warning signals" of technology convergence formation and industry convergence. ...
... Knowledge reuse is the application of previously created knowledge to solve a current problem (see, e.g., [30] and [31]). It captures the degree of underlying scientific similarity between communities, and in our setting, it is measured as previous articles being referred to in both the ACM and the IEEE fields (i.e., citation of the same article in both communities). ...
Article
Full-text available
While mastering technology and industry convergence are essential for firms across a growing number of industries, convergence is often rapid and abrupt, challenging firms to develop appropriate strategic responses. Focusing on the historical convergence between information technology and communication technology, we examine the microlevel behaviors of scientists initiating and driving convergence. Analyzing a bibliometric dataset of 257 641 scientific articles, we demonstrate how industry convergence manifests in a microlevel scientific convergence, preceding industry convergence by several decades. Our article contributes to the literature on convergence by developing new bibliometric measures for scientific convergence, and by contrasting microlevel behaviors that underpin convergence. Based on our findings, we offer a set of methods and strategies to assist managers in technology-based businesses with anticipating and responding to convergence in a timely manner.
... The actual activities of software contributors have been directly investigated with a focus on their emergent, decentralized character (Crowston, Li, Wei, Eseryel, & Howison, 2007;Crowston & Scozzi, 2008; see also Aksulu &Wade, 2010, andWiggins, 2012, for recent literature reviews discussing this stream of research). Reuse of software code has been investigated as a specific form of knowledge recombination fostering the ability to generate innovation in F/OSS production (Haefliger, von Krogh, & Spaeth, 2008). ...
Chapter
Full-text available
We examine the interconnected system of individual decisions emerging from problem-solving activities performed by 135 volunteer contributors on 719 software bugs reported in Epiphany - a Free/Open Source Software project. Using Stochastic Actor-Oriented models (SAOMs), we treat the evolving two-mode network produced by encounters between carriers of organizational solutions (contributors) and organizational problems (software bugs) as a dynamic opportunity structure that constrains and enables organizational decision making. We document how stable local configurations linking problems and solutions are induced by – while at the same time sustaining decentralized problem-solving activities with meaningful self-organizing properties. We discuss how the reproduction and stabilization of problem-solution matches - or organizational "routines," may be interpreted as by-products of local network dependencies.
... Code reuse is a well-known practice aimed at improving both developers productivity and code quality [7]. There is evidence about the benefits of systematically reusing code, especially for what concerns a lower likelihood of having bugs in reused code [6], [11], [8], [12]. Such benefits arise when the reused code is not outdated [15] and follows good patterns of code reuse [10]. ...
Preprint
Reusing code is a common practice in software development: It helps developers speedup the implementation task while also reducing the chances of introducing bugs, given the assumption that the reused code has been tested, possibly in production. Despite these benefits, opportunities for reuse are not always in plain sight and, thus, developers may miss them. We present our preliminary steps in building RETIWA, a recommender able to automatically identify custom implementations in a given project that are good candidates to be replaced by open source APIs. RETIWA relies on a ``knowledge base'' consisting of real examples of custom implementation-to-API replacements. In this work, we present the mining strategy we tailored to automatically and reliably extract replacements of custom implementations with APIs from open source projects. This is the first step towards building the envisioned recommender.
... As mentioned previously, all game components can be offshelf assets, open-source, or self-developed. While offshelf and open source components might be too generic or do not work well with other components, combining various elements from existing products into a new product can also pose multiple technical and non-technical challenges (Kim and Stohr 1998;Haefliger et al. 2008). Assuming that the technical challenges can be mastered, managers still need to address the non-technical code reuse issues. ...
Article
Full-text available
The mobile games business is an ever-increasing sub-sector of the entertainment industry. Due to its high profitability but also high risk and competitive atmosphere, game publishers need to develop strategies that allow them to release new products at a high rate, but without compromising the already short lifespan of the firms' existing games. Successful game publishers must enlarge their user base by continually releasing new and entertaining games, while simultaneously motivating the current user base of existing games to remain active for more extended periods. Since the core-component reuse strategy has proven successful in other software products, this study investigates the advantages and drawbacks of this strategy in mobile games. Drawing on the widely accepted Product Life Cycle concept, the study investigates whether the introduction of a new mobile game built with core-components of an existing mobile game curtails the incumbent's product life cycle. Based on real and granular data on the gaming activity of a popular mobile game, the authors find that by promoting multi-homing (i.e., by smartly interlinking the incumbent and new product with each other so that users start consuming both games in parallel), the core-component reuse strategy can prolong the lifespan of the incumbent game.
... The reuse of third-party software libraries can affect OSS projects (Constantinou et al., 2015;Zaimi et al., 2015). Many studies of OSS projects found that the reuse of third-party libraries is common in such projects (Constantinou et al., 2015;Haefliger et al., 2008;Schwittek & Eicker, 2013;Zaimi et al., 2015). Constantinou et al. (2015) observed that the object-oriented design quality of white box reused classes was higher than that of system classes. ...
Thesis
Full-text available
The study addresses the problem of the inadequacy of conventional software testing methods to detect all software defects. This problem affects software users and researchers due to poor software performance, reduced precision or accuracy of software output, and retractions of research publications. Detecting software defects may also be challenging due to the oracle problem. Existing research supports the metamorphic testing method's effectiveness for handling the oracle problem and finding software defects that conventional testing methods cannot detect. The research questions ask about the relationships among the use and acceptance of the metamorphic testing method among open-source developers and the constructs of performance expectancy and effort expectancy. The study's purpose was to examine these relationships. Another objective of the study was to understand how the variables of age, gender, and experience moderate these relationships. The guiding theoretical framework of the study was the unified theory of acceptance and use of technology. In this study, a quantitative methodology with a correlational design was employed. The participants were contributors to open-source software projects contained in the GitHub “Software in science” collection. The data was collected via an online survey instrument. The data were analyzed using Spearman’s rank-order correlation tests and moderated multiple regression analysis. Moderate to strong positive relationships were found between both the performance expectancy and effort expectancy and the acceptance and use of metamorphic testing. This finding suggests that increasing the extent to which developers believe that metamorphic testing will improve their job performance and improving its ease of use will increase the adoption of metamorphic testing. The creation of interventions to educate developers on the use of metamorphic testing is recommended. The study results support the applicability of the unified theory of acceptance and use of technology to software testing methods. Future research could involve studying the relationship between metamorphic testing adoption and other factors, such as social influence and facilitating conditions.
... Some of the widely reused components involved a set of hundreds of files. Haefliger et al. [7] studied the extent of source code reuse in open source projects, using quantitative data (through mining source code repositories) and qualitative data (through interviews with developers) gathered from a sample of six medium to large open source projects. The main finding of their study showed that source code reuse was quite extensive across the sample of projects studied, with developers actively reusing available code and other knowledge that solved their technical problems. ...
Preprint
One of the purported ways to increase productivity and reduce development time is to reuse existing features and modules. If reuse is adopted, logically then, it will have a direct impact on a system's evolution. However, the evidence in the literature is not clear on the extent to which reuse is practiced in real-world projects, nor how it is practiced. In this paper we report the results of an investigation of reuse and evolution of software features in one of the largest open-source ecosystems - Eclipse. Eclipse provides a leading example of how a system can grow dramatically in size and number of features while maintaining its quality. Our results demonstrate the extent of feature reuse and evolution and also patterns of reuse across ten different Eclipse releases (from Europa to Neon).
... Secondly, if the organisation incorporates OSS in the software that it publishes (whether for profit or not) it needs to know what requirements it must satisfy (these requirements are imposed by the software licenses of the components that it incorporates). Moreover, in software engineering research, OSS licensing is an important parameter in areas, such as project management, requirements and reusability [3]. Thus, adopting an OSS component requires both an informed process to evaluate the legal ramifications of using the component and a process to ensure that the component is used according to its license (license compliance). ...
Preprint
Full-text available
Free and open source software is widely used in the creation of software systems, whereas many organisations choose to provide their systems as open source. Open source software carries licenses that determine the conditions under which the original software can be used. Appropriate use of licenses requires relevant expertise by the practitioners, and has an important legal angle. Educators and employers need to ensure that developers have the necessary training to understand licensing risks and how they can be addressed. At the same time, it is important to understand which issues practitioners face when they are using a specific open source license, when they are developing new open source software products or when they are reusing open source software. In this work, we examine questions posed about open source software licensing using data from the following Stack Exchange sites: Stack Overflow, Software Engineering, Open Source and Law. We analyse the indication of specific licenses and topics in the questions, investigate the attention the posts receive and trends over time, whether appropriate answers are provided and which type of questions are asked. Our results indicate that practitioners need, among other, clarifications about licensing specific software when other licenses are used, and for understanding license content. The results of the study can be useful for educators and employers, organisations that are authoring open source software licenses and developers for understanding the issues faced when using licenses, whereas they are relevant to other software engineering research areas, such as software reusability.
... Past research that has attempted this link involved automatic generation of documentation from code such as with SAS [15] and Lambda expressions in Java [1], automatic generation of code from documentation such as with CON-CODE [8] and visualising traceability links between the artefacts [7]. ...
Chapter
Full-text available
Context: Constant evolution in software systems often results in its documentation losing sync with the content of the source code. The traceability research field has often helped in the past with the aim to recover links between code and documentation, when the two fell out of sync. Objective: The aim of this paper is to compare the concepts contained within the source code of a system with those extracted from its documentation, in order to detect how similar these two sets are. If vastly different, the difference between the two sets might indicate a considerable ageing of the documentation, and a need to update it. Methods: In this paper we reduce the source code of 50 software systems to a set of key terms, each containing the concepts of one of the systems sampled. At the same time, we reduce the documentation of each system to another set of key terms. We then use four different approaches for set comparison to detect how the sets are similar. Results: Using the well known Jaccard index as the benchmark for the comparisons, we have discovered that the cosine distance has excellent comparative powers, and depending on the pre-training of the machine learning model. In particular, the SpaCy and the FastText embeddings offer up to 80% and 90% similarity scores. Conclusion: For most of the sampled systems, the source code and the documentation tend to contain very similar concepts. Given the accuracy for one pre-trained model (e.g., FastText), it becomes also evident that a few systems show a measurable drift between the concepts contained in the documentation and in the source code.
... Legal issues of ownership and control continue unabated. For example, the open source movement used copyrights and licenses to combat code restrictions (Raymond, 1999;Stallman, 1999) and is still relying on an array of legal devices to prosper by enabling extensive reuse of software components (Haefliger, von Krogh, and Spaeth, 2008), thus expanding search in a cost-effective manner. Without licenses that govern the inspection, modification, and use of the source code, open source would likely have followed a very different trajectory and found it much harder to achieve the global integration into hardware and systems it has today. ...
Article
Full-text available
This paper sheds fresh light on our 2010 paper How Open Is Innovation by taking into consideration notable developments in innovation over the last decade. The original paper developed four types of openness: sourcing, acquiring, selling, and revealing. Reflecting on important technological, organizational, and societal changes in the past decade, we highlight how these changes prompt novel questions for open innovation. While the core features of the original framework still stands, there are many new questions that have emerged in recent years. We end by charting a path for future research that emphasizes opportunities, costs and tradeoffs between different modes of open innovation, the need to better understand the nature of data, new organizational designs and legal instruments, and multilevel aspects and relationships that affect the extent and nature of openness.
... Successful OSS initiatives can effectively change the method of software development [30,39], improve software development efficiency [31,60], and ensure software quality through effective management [1,58]. Many projects have emerged along with the increasing number of users participating in the development of the OSS community [28]. ...
Preprint
While many forms of financial support are currently available, there are still many complaints about inadequate financing from software maintainers. In May 2019, GitHub, the world's most active social coding platform, launched the Sponsor mechanism as a step toward more deeply integrating open source development and financial support. This paper collects data on 8,028 maintainers, 13,555 sponsors, and 22,515 sponsorships and conducts a comprehensive analysis. We explore the relationship between the Sponsor mechanism and developers along four dimensions using a combination of qualitative and quantitative analysis, examining why developers participate, how the mechanism affects developer activity, who obtains more sponsorships, and what mechanism flaws developers have encountered in the process of using it. We find a long-tail effect in the act of sponsorship, with most maintainers' expectations remaining unmet, and sponsorship has only a short-term, slightly positive impact on development activity but is not sustainable. While sponsors participate in this mechanism mainly as a means of thanking the developers of OSS that they use, in practice, the social status of developers is the primary influence on the number of sponsorships. We find that both the Sponsor mechanism and open source donations have certain shortcomings and need further improvements to attract more participants.
... Another prominent area of application is in the study of agile development methods, where researchers highlight the benefits of agile methods for enabling exploration (Ramesh et al., 2012;Vidgen & Wang, 2009;Vinekar et al., 2006). March's framing of organizational learning has also been widely applied to open source software development effort, with a particular focus on the exploratory benefits that open source software development engenders (Garzarelli & Fontanella, 2011;Haefliger et al., 2008;Henningsson, 2015;Lichtenthaler, 2011). Finally, ambidexterity theory has been widely applied to the study of software development environments, including in the assessment of distinct development methodologies (Ramesh et al., 2012), sourcing arrangements (Aubert et al., 2015), control processes (Tiwana, 2010;Tiwana & Keil, 2009), project management styles (Gregory & Keil, 2014), and organizational application management strategies (Queiroz et al., 2018). ...
Article
In recent years, consortium-based open source software (COSS) development has emerged as a strategic alternative to resource-intensive in-house development and misaligned commercial software acquisition. Yet consortia undertaking such collaborative efforts struggle to balance the oft-competing demands of innovation and sustainability. Drawing upon a longitudinal case study of the Kuali initiative, this analysis examines the mechanisms of exploration and exploitation involved in developing and sustaining a COSS approach. Based on our findings in the Kuali case, we develop a conceptual framework to discern whether and how COSS development initiatives can achieve contextual ambidexterity, balancing the strategic goals of innovation and sustainability over time. While exploration- and exploitation-oriented efforts compete for resources, our analysis reveals that they may also complement one another across distinct layers of institutional activity. The contextual ambidexterity is achieved through multi-level collaboration enabled by a modular technical and organizational design.
... Центральною ланкою по суті всіх об'єктноорієнтованих методів є діаграми класів, що показано в [13,16,[17][18][19]. Діаграма класів використовуються для відображення типів об'єктів програмної реалізації та різного роду статичних зв'язків, які існують між цими об'єктами. ...
Article
Розглянуті питання можливості застосування механізму повторного використання коду в процесі проектування та розробки програмного забезпечення знання-орієнтованих систем. Доведена необхідність окремого дослідження питань розробки програмного забезпечення аналітичного та інформаційного ресурсів, що забезпечують підтримку всіх учасників процесу розробки програмного забезпечення знання-орієнтованих систем. Показана необхідність використання механізмів повторного використання раніше розробленого і верифікованого програмного коду, як елементу інформаційного ресурсу. В рамках розробленого методу підвищення надійності програмного забезпечення знання-орієнтованих систем за рахунок механізмів повторного використання коду запропонована нова візуальна форма подання бібліотек функцій у вигляді єдиної програмної оболонки. В якості базового інструментарію вирішення завдання розробки інформаційного ресурсу запропоновано використовувати UML (Unified Modeling Language) – уніфіковану мову моделювання, в основу якої покладено парадигму об'єктно-орієнтованого програмування. Зазначений вибір обґрунтований тим, що UML є невід'ємною частиною уніфікованого процесу розробки програмного забезпечення та по суті являється відкритим стандартом, що використовує графічні позначення для створення абстрактної моделі системи. Отримані теоретичні положення відображені в наскрізному прикладі, що відображає однин з можливих варіантів організації бібліотек функцій як елементу інформаційного ресурсу. Розроблено та обґрунтовано діаграми варіантів використання, діаграми взаємодії, діаграми послідовності, діаграми класів. На основі отриманих практичних результатів запропоновано структурну схему методу, яка, на відміну від існуючих рішень включає процедуру вироблення коректур для основних UML-діаграм за вимогами середовищ програмування.
... Code examine facility increases the trust of the public into software. A report published by Standish Group in 2008 in which it is mentioned that OSS software development model increased the savings of approximately $60 billion per year for consumers [5][6] [7]. ...
Article
Full-text available
Open source software system is becoming in trend due to its quality, security and low cost development. Two types of developer's team may work in such kind of software's. First kind of developers are the core developers and second kind of developers are the public developers who come from the public domain contribute in the software development voluntarily. This research paper focuses on the development of open source software within limited time frame using some AI based project automation tools.
... Haefliger, von Krogh and Spaeth [21] studied the reuse pattern and practices in open source applications. Their study showed that experienced developers reuse more code than less experienced developers. ...
Preprint
Full-text available
With the popularity of software ecosystems, the number of open source components (known as packages) has grown rapidly. Identifying high-quality and well-maintained packages from a large pool of packages to depend on is a basic and important problem, as it is beneficial for various applications, such as package recommendation and package search. However, no systematic and comprehensive work focuses on addressing this problem except in online discussions or informal literature and interviews. To fill this gap, in this paper, we conducted a mixed qualitative and quantitative analysis to understand how developers identify and select relevant open source packages. In particular, we started by surveying 118 JavaScript developers from the npm ecosystem to qualitatively understand the factors that make a package to be highly-selected within the npm ecosystem. The survey results showed that JavaScript developers believe that highly-selected packages are well-documented, receive a high number of stars on GitHub, have a large number of downloads, and do not suffer from vulnerabilities. Then, we conducted an experiment to quantitatively validate the developers' perception of the factors that make a highly-selected package. In this analysis, we collected and mined historical data from 2,527 packages divided into highly-selected and not highly-selected packages. For each package in the dataset, we collected quantitative data to present the factors studied in the developers' survey. Next, we used regression analysis to quantitatively investigate which of the studied factors are the most important. Our regression analysis complements our survey results about highly-selected packages. In particular, the results showed that highly-selected packages tend to be correlated by the number of downloads, stars, and how large the package's readme file is.
... Haefliger, von Krogh and Spaeth [21] studied the reuse pattern and practices in open source applications. Their study showed that experienced developers reuse more code than less experienced developers. ...
Preprint
With the popularity of software ecosystems, the number of open source components (known as packages) has grown rapidly. Identifying high-quality and well-maintained packages from a large pool of packages to depend on is a basic and important problem, as it is beneficial for various applications, such as package recommendation and package search. However, no systematic and comprehensive work focuses on addressing this problem except in online discussions or informal literature and interviews. To fill this gap, in this paper, we conducted a mixed qualitative and quantitative analysis to understand how developers identify and select relevant open source packages. In particular, we started by surveying 118 JavaScript developers from the npm ecosystem to qualitatively understand the factors that make a package to be highly-selected within the npm ecosystem. The survey results showed that JavaScript developers believe that highly-selected packages are well-documented, receive a high number of stars on GitHub, have a large number of downloads, and do not suffer from vulnerabilities. Then, we conducted an experiment to quantitatively validate the developers' perception of the factors that make a highly-selected package. In this analysis, we collected and mined historical data from 2,527 packages divided into highly-selected and not highly-selected packages. For each package in the dataset, we collected quantitative data to present the factors studied in the developers' survey. Next, we used regression analysis to quantitatively investigate which of the studied factors are the most important. Our regression analysis complements our survey results about highly-selected packages. In particular, the results showed that highly-selected packages tend to be correlated by the number of downloads, stars, and how large the package's readme file is.
... (whether for profit or not) it needs to know what requirements it must satisfy (these requirements are imposed by the software licenses of the components that it incorporates). Moreover, in software engineering research, OSS licensing is an important parameter in areas, such as project management, requirements and reusability (Haefliger et al., 2008). Thus, adopting an OSS component requires both an informed process to evaluate the legal ramifications of using the component and a process to ensure that the component is used according to its license (license compliance). ...
Article
Free and open source software is widely used in the creation of software systems, whereas many organisations choose to provide their systems as open source. Open source software carries licenses that determine the conditions under which the original software can be used. Appropriate use of licenses requires relevant expertise by the practitioners, and has an important legal angle. Educators and employers need to ensure that developers have the necessary training to understand licensing risks and how they can be addressed. At the same time, it is important to understand which issues practitioners face when they are using a specific open source license, when they are developing new open source software products or when they are reusing open source software. In this work, we examine questions posed about open source software licensing using data from the following Stack Exchange sites: Stack Overflow, Software Engineering, Open Source and Law. We analyse the indication of specific licenses and topics in the questions, investigate the attention the posts receive and trends over time, whether appropriate answers are provided and which type of questions are asked. Our results indicate that practitioners need, among other, clarifications about licensing specific software when other licenses are used, and for understanding license content. The results of the study can be useful for educators and employers, organisations that are authoring open source software licenses and developers for understanding the issues faced when using licenses, whereas they are relevant to other software engineering research areas, such as software reusability.
Article
Software Quality is an important factor in software industry which depends on many factor involving process and product development. In this era achieving standard quality level in software is very important because of the high customer demands. This paper identifies reviews and addresses the factors affecting the quality of software in long run and indirectly suggests improvement for achieving it.
Preprint
When inspiring software developers to contribute to open source software, the act is often referenced as an opportunity to build tools to support the developer community. However, that is not the only charge that propels contributions -- growing interest in open source has also been attributed to software developers deciding to use their technical skills to benefit a common societal good. To understand how developers identify these projects, their motivations for contributing, and challenges they face, we conducted 21 semi-structured interviews with OSS for Social Good (OSS4SG) contributors. From our interview analysis, we identified themes of contribution styles that we wanted to understand at scale by deploying a survey to over 5765 OSS and Open Source Software for Social Good contributors. From our quantitative analysis of 517 responses, we find that the majority of contributors demonstrate a distinction between OSS4SG and OSS. Likewise, contributors described definitions based on what societal issue the project was to mitigate and who the outcomes of the project were going to benefit. In addition, we find that OSS4SG contributors focus less on benefiting themselves by padding their resume with new technology skills and are more interested in leaving their mark on society at statistically significant levels. We also find that OSS4SG contributors evaluate the owners of the project significantly more than OSS contributors. These findings inform implications to help contributors identify high societal impact projects, help project maintainers reduce barriers to entry, and help organizations understand why contributors are drawn to these projects to sustain active participation.
Article
This paper offers insights on how digital artefacts foster coordination of individuals in distributed innovation projects by limiting the divergence of team members’ representations of the project. This role is particularly important when coordination mechanisms such as leadership and modularity show some limits. Using distributed innovation in open-source software as a setting, we develop and test the hypotheses that (1) the release of initial code in open-source software projects limits the divergence of team members’ representations and (2) limiting divergence of team members’ representations triggered by initial code release implies a higher probability of project survival, a non-trivial goal in such a setting. To test our hypotheses, we draw on a dataset of 5,703 open-source software projects registered on SourceForge.net. Both our hypotheses are supported, pointing towards fruitful directions for expanding research on the way distributed innovation processes are carried out when digital artefacts are involved.
Article
GitHub hosts hundreds of millions of code repositories written in hundreds of different programming languages. In addition to its hosting services, GitHub provides data and insights into code, such as vulnerability analysis and code navigation, with which users can improve and understand their software development process. GitHub has built Semantic, a program analysis tool capable of parsing and extracting detailed information from source code. The development of Semantic has relied extensively on the functional programming literature; this paper describes how connections to academic research inspired and informed the development of an industrial-scale program analysis toolkit.
Article
Background and Objective: Cloud computing has the ability to offload processing tasks to a remote computing resources. Presently, the majority of biomedical digital signal processing involves a ground-up approach by writing code in a variety of languages. This may reduce the time a researcher or health professional has to process data, while increasing the barrier to entry to those with little or no software development experience. In this study, we aim to provide a service capable of handling and processing biomedical data via a code-free interface. Furthermore, our solution should support multiple file formats and processing languages while saving user inputs for repeated use. Methods: A web interface via the Python-based Django framework was developed with the potential to shorten the time taken to create an algorithm, encourage code reuse, and democratise digital signal processing tasks for non-technical users using a code-free user interface. A user can upload data, create an algorithm and download the result. Using discrete functions and multi-lingual scripts (e.g. MATLAB or Python), the user can manipulate data rapidly in a repeatable manner. Multiple data file formats are supported by a decision-based file handler and user authentication-based storage allocation method. Results: The proposed system has been demonstrated as effective in handling multiple input data types in various programming languages, including Python and MATLAB. This, in turn, has the potential to reduce currently experienced bottlenecks in cross-platform development of bio-signal processing algorithms. The source code for this system has been made available to encourage reuse. A cloud service for digital signal processing has the ability to reduce the apparent complexity and abstract the need to understand the intricacies of signal processing. Conclusion: We have introduced a web-based system capable of reducing the barrier to entry for inexperienced programmers. Furthermore, our system is reproducable and scalable for use in a variety of clinical or research fields.
Article
Online innovation communities encourage innovators to build upon others' prior work (i.e., remixing). This generative user innovation necessitates new theorization to better understand the interplay between characteristics of the source innovation and the community's collective motivation. Motivation is a heightened concern in online communities where contributors often select which problems warrant their effort. Two studies improve our understanding of how the community's motivations compel remixing and impact two aspects of the depth of these remixes (improvement and differentness). First, hypotheses regarding the community's collective remix response are developed and tested. After this, an exploratory (fsQCA) study seeks out configurations of these motivations that consistently result in improved and different remixes. Using data from thingiverse.com, we show that established motivations for user innovation (enjoyment, learning, use-value) motivate remixing, but learning and use-value's effects are moderated by source innovation quality. Learning and use-value are only impactful for high quality source objects. We also demonstrate that originality of the source object has an inverted-U relationship with remixing; innovations need to be novel, but not drastically different from expectations to generate a remix response from the community.
Preprint
Full-text available
Online innovation communities encourage innovators to build upon others' prior work (i.e., remixing). This generative user innovation necessitates new theorization to better understand the interplay between characteristics of the source innovation and the community's collective motivation. Motivation is a heightened concern in online communities where contributors often select which problems warrant their effort. Two studies improve our understanding of how the community's motivations compel remixing and impact two aspects of the depth of these remixes (improvement and differentness). First, hypotheses regarding the community's collective remix response are developed and tested. After this, an exploratory (fsQCA) study seeks out configurations of these motivations that consistently result in improved and different remixes. Using data from thingiverse.com, we show that established motivations for user innovation (enjoyment, learning, use-value) motivate remixing, but learning and use-value's effects are moderated by source innovation quality. Learning and use-value are only impactful for high quality source objects. We also demonstrate that originality of the source object has an inverted-U relationship with remixing; innovations need to be novel, but not drastically different from expectations to generate a remix response from the community.
Article
Emerging digital technologies give rise to digital entrepreneurship and the widespread phenomenon of open source collaboration (OSC) on GitHub for entrepreneurial pursuits. Although openness is a common theme in digital entrepreneurship, it is unclear how digital startups—that is, startups that that have digital artifacts at the core of their business model for value creation and capture—actually realize value from their OSC engagement. We develop a theoretical framework to explain how the engagement in OSC may affect the value of digital startups and how the effect is contingent on the stage of venture maturity (conception, commercialization, or growth) and the mode of OSC engagement (inbound or outbound). In analyses that pool 17,552 matched digital startups with monthly panel observations between 2008 and 2017, we find digital startups in the conception and commercialization stages benefit more from inbound OSC whereas the ones in the growth stage benefit more from outbound OSC. As digital startups increasingly use OSC for ideation, experimentation, and scaling, our contribution is to show whether, when, and how knowledge flows through OSC might affect the value of digital startups. We discuss implications for research on organizing for digital entrepreneurship as well as open innovation.
Article
A useful theoretical lens for understanding innovation in the strategy and entrepreneurship literatures is knowledge recombination. According to a recombination logic, innovations come about by recombining knowledge components, each of which is associated with a core scientific or technological concept. Interactions among a set of recombined components give rise to new meanings and functions that become the basis of an innovation. The singular focus on the components of knowledge underlying an innovation makes knowledge recombination stand out from other theoretical approaches. The rapid growth in research utilizing a recombination logic suggests that the time is ripe for stepping back and assessing its key insights. Therefore, this review provides a framework for a recombination perspective and considers how the literature using a recombination approach has progressed over time, including identification of key features of knowledge components, influences on how components are recombined, and the outcomes of recombination. Finally, a number of new directions for research are proposed.
Thesis
Depuis l’entrée en vigueur de la Loi pour une République numérique en 2016, toutes les collectivités de plus de 3500 habitants ont l’obligation de publier leurs données de manière accessible, gratuitement et dans un format ne nécessitant pas l’utilisation d’un logiciel spécifique. Derrière la loi transparaît la promesse de voir émerger de nouvelles applications, services, informations issues de l’utilisation que le public ferait des données ouvertes. Or, si l’ouverture des données publiques se veut être un facteur qui encourage le développement de nouveaux usages, une telle démarche n’est pas nécessairement un gage de succès. En effet, depuis 2016, très peu d’usages utilisant l’ouverture des données ont vu le jour, à tel point que certains activistes définissent la période actuelle comme celle du “baby blues de l’open data”. Dans ce cadre, l’objet de cette thèse est de construire un dispositif en Système d’Information pour lever les barrières qui freinent la construction des usages. Une approche par le design science a été adoptée. Une première phase qualitative a permis de développer un modèle théorique de compréhension des phénomènes à l'œuvre dans la construction des usages des données ouvertes et des barrières socio-techniques qui freinent le processus. Une seconde phase de conception a permis de construire le design d’un dispositif en Système d’Information appelé Open Data Canvas qui permet de lever ces barrières. Il s’appuie sur trois théories : la théorie de la construction sociale de la technologie, la théorie de la cognition distribuée et la théorie du middleground. Enfin, une dernière phase dite d’évaluation a permis d’interroger les usagers des données ouvertes sur l’utilité perçue de l’Open Data Canvas. Ces trois phases se sont affinées itérativement pour permettre au Canvas de s’intégrer dans le quotidien des usagers des données ouvertes.
Article
This paper focuses on the interplay between firms and open and collaborative innovation communities. We develop a formal model where both volunteers (agents setting their agendas freely) and firm’s employees (agents whose agenda is mostly set by their employer) participate in the creation of a common artifact. In this framework, we discuss how firms can influence the architecture of the emerging product to assure fast and performant development and a desirable distribution of innovative labor within the project team. We find that closing the project only to employees implies high speed and performance if employees are given autonomy in certain dimensions and are directed in others. In this case, however, we observe a trade-off in terms of ideal core–periphery division of labor on one side and development speed and performance on the other side. At the opposite extreme, creating a volunteer-only project can ease the trade-off but assures positive results only if the firm is able to set up an entry mechanism that “surgically” selects volunteers with specific preferences. A mixture of both employees and volunteers can strike a good balance, relaxing the two constraints.
Chapter
A promising way to support software reuse is based on Component-Based Software Development (CBSD). Open Source Software (OSS) products are increasingly available that can be freely used in product development. However, OSS communities still face several challenges before taking full advantage of the “reuse mechanism”: many OSS projects duplicate effort, for instance when many projects implement a similar system in the same application domain and in the same topic. One successful counter-example is the FFmpeg multimedia project; several of its components are widely and consistently reused in other OSS projects. Documented is the evolutionary history of the various libraries of components within the FFmpeg project, which presently are reused in more than 140 OSS projects. Most use them as black-box components; although a number of OSS projects keep a localized copy in their repositories, eventually modifying them as needed (white-box reuse). In both cases, the authors argue that FFmpeg is a successful project that provides an excellent exemplar of a reusable library of OSS components.
Article
Full-text available
This paper provides a quantitative study of free revealing of firm-developed innovations within embedded Linux. Firms voluntarily contribute developments back to public projects, receiving informal development support. Revealing selectively still allows them to protect their intellectual property. Revealing is strongly heterogeneous among firms, which can partly be explained by firm characteristics.
Article
Full-text available
Today's industrial landscape is characterized by rapid change and systemic technologies. Rapid change results in ever shorter product life cycles that demand continual innovation from firms. The systemic nature of technologies makes it difficult, if not impossible, for any one firm to manufacture all components of a technological system. We propose that these challenges be met by designing technological systems that have the potential to yield economies of substitution. Additionally, we propose that these economies be realized by adopting the network mode of governance. We examine the network mode at three levels—intrafirm, interfirm, and institutional—to illuminate the inherent tension between cooperation and competition at each level, and to explore the implications of this tension for industrial dynamics.
Article
Full-text available
A number of issues are covered in this paper. Chief among them is the need for greater discipline in understanding the economic benefits of software reuse within the context of a broader business strategy. While traditional methods fail to account for growth opportunities and flexibility generated by investments in reuse, the introduction of option pricing theory can greatly enhance the design and evaluation of software reuse projects. Similarly, the disciplines of business strategy hold promise to help to fill the void of “strategic context” within which reuse investment happens.
Article
Full-text available
The motives of 141 contributors to a large Open Source Software (OSS) project (the Linux kernel) was explored with an Internet-based questionnaire study. Measured factors were both derived from discussions within the Linux community as well as from models from social sciences. Participants’ engagement was particularly determined by their identification as a Linux developer, by pragmatic motives to improve own software, and by their tolerance of time investments. Moreover, some of the software development was accomplished by teams. Activities in these teams were particularly determined by participants’ evaluation of the team goals as well as by their perceived indispensability and self-efficacy.
Article
Full-text available
This paper provides a quantitative study (N = 268) of patterns of free revealing of firm-developed innovations within embedded Linux, a type of open source software (OSS). I find that firms, without being obliged to do so, contribute many of their own developments back to public embedded Linux code, eliciting and indeed receiving informal development support from other firms. That is, they perform a part of their product development open to the public—an unthinkable idea for traditionally minded managers. Such openness obviously entails the challenge of protecting one's intellectual property. I find that firms address this issue by revealing selectively. They reveal, on average, about half of the code they have developed, while protecting the other half by various means. Revealing is strongly heterogeneous among firms. Multivariate analysis can partly explain this heterogeneity by firm characteristics and the firm's purpose behind revealing. An analysis of reasons for revealing and of the type of revealed code shows that different types of firms have different rationales for openness. Implications for management are that the conflict between downsides and benefits of openness appears manageable. Provided selective revealing is practiced deliberately, the opportunities of open development dominate.
Article
Full-text available
As organizations implement systematic software reuse programs to improve productivity and quality, they must be able to measure their progress and identify the most effective reuse strategies. This is done with reuse metrics and models. In this article we survey metrics and models of software reuse and reusability, and provide a classification structure that will help users select them. Six types of metrics and models are reviewed: cost-benefit models, maturity assessment models, amount of reuse metrics, failure modes models, reusability assessment models, and reuse library metrics.
Article
Full-text available
This paper argues that the architecture of a codebase is a critical factor that lies at the heart of the open source development process. We define two observable properties of an architecture: (1) modularity and (2) option value. Developers can often make informed judgments about modularity and option value from early, partially implemented code releases. We show that codebases that are more modular or have more option value (1) increase developers' incentives to join and remain involved in an open source development effort and (2) decrease the amount of free riding in equilibrium. These effects occur because modularity and option value create opportunities for the exchange of valuable work among developers, opportunities that do not exist in codebases that are not modular or have no option value.
Article
Full-text available
This paper reports data from a study that seeks to characterize the differences in design structure between complex software products. We use design structure matrices (DSMs) to map dependencies between the elements of a design and define metrics that allow us to compare the structures of different designs. We use these metrics to compare the architectures of two software products--the Linux operating system and the Mozilla Web browser--that were developed via contrasting modes of organization: specifically, open source versus proprietary development. We then track the evolution of Mozilla, paying attention to a purposeful "redesign" effort undertaken with the intention of making the product more "modular." We find significant differences in structure between Linux and the first version of Mozilla, suggesting that Linux had a more modular architecture. Yet we also find that the redesign of Mozilla resulted in an architecture that was significantly more modular than that of its predecessor and, indeed, than that of Linux. Our results, while exploratory, are consistent with a view that different modes of organization are associated with designs that possess different structures. However, they also suggest that purposeful managerial actions can have a significant impact in adapting a design's structure. This latter result is important given recent moves to release proprietary software into the public domain. These moves are likely to fail unless the product possesses an "architecture for participation."
Article
Full-text available
The software reuse strategies for improving software development efficiency and black box reuse with component markets is discussed. The broad reuse strategies includes white broad reuse, black box reuse with in house component development and black box reuse with component procured from the market place. It is observed that in choosing among the reuse strategies organizations are confronted with a trade-off between component acquistion costs and component customization costs. It is argued that component market could play an important role in making well written components available to developers and supply chains perform the dual role of market mediation and distribution.
Article
Full-text available
Software patterns are promising tools for creating solutions to common software problems. These patterns, which are recurring solutions to a standard problem, can be integrated to form a language that provides a process for the orderly resolution of software development problems. They help software developers communicate architectural knowledge and learn a new design paradigm or architectural style.
Article
Full-text available
The capabilities of a firm, or any organization, lie primarily in the organizing principles by which individual and functional expertise is structured, coordinated, and communicated. Firms are social communities which use their relational structure and shared coding schemes to enhance the transfer and communication of new skills and capabilities. To replicate new knowledge in the absence of a social community is difficult. A classic demonstration is the well-studied problem of the transfer across country borders of manufacturing capabilities that support production of new product innovations. We show in this article that the degree of codification and how easily capabilities are taught has a significant influence on the speed of transfer. What makes the question of knowledge codification particularly interesting is that firms compete not only through the creation, replication, and transfer of their own knowledge, but also through their ability to imitate the product innovations of competitors. The capacity to speed the internal transfer of a production capability to new markets (e.g., those in other countries) is, consequently, of fundamental significance in a competitive environment. In the attempt to speed the internal transfer of knowledge, the dilemma arises that capabilities which can be easily communicated within the firm are more likely to be easily imitated by competitors. This relationship is tested by analyzing the effects of the ease of codifying and communicating a manufacturing capability not only on the time to its transfer, but also on the time to imitation of the new product. ’The determinants of the time to imitation are found to be the extent to which knowledge of the manufacturing processes is “common” among competitors, and the degree of continuous recombination of capabilities leading to improvement of the product or the manufacturing process. We support this interpretation by a discussion of the results from field research. A wider implication of these findings is the proposition that the transfer and recombination of organizational capabilities are the foundation of an evolutionary theory of the firm. A critical element limiting the expansion of a firm is that the competitive value of codifying knowledge leads to the selection of organizing principles that are not functional in all competitive environments. The pressure of speed is of critical importance to understand the evolutionary advantage of nonoptimal rules of coordinated action within a social community.
Article
Full-text available
Theorists often speculate why open source and free software project contributors give their work away. Although contributors make their work publicly available, they do not forfeit their rights to it. Community managed software projects protect their work by using several legal and normative tactics, which should not be conflated with a disregard for or neglect of intellectual property rights. These tactics allow a project’s intellectual property to be publicly and freely available and yet, governable. Exploration of this seemingly contradictory state may provide new insight into governance models for the management of digital intellectual property.
Article
Currently, two models of innovation are prevalent in organization science. The "private investment" model assumes returns to the innovator result from private goods and efficient regimes of intellectual property protection. The "collective action" model assumes that under conditions of market failure, innovators collaborate in order to produce a public good. The phenomenon of open source software development shows that users program to solve their own as well as shared technical problems, and freely reveal their innovations without appropriating private returns from selling the software. In this paper, we propose that open source software development is an exemplar of a compound "private-collective" model of innovation that contains elements of both the private investment and the collective action models and can offer society the "best of both worlds" under many conditions. We describe a new set of research questions this model raises for scholars in organization science. We offer some details regarding the types of data available for open source projects in order to ease access for researchers who are unfamiliar with these, and also offer some advice on conducting empirical studies on open source software development processes.
Conference Paper
Software reuse is the second oldest programming profession. Ever since the first program logic board was wired, people have been looking for ways of saving time and money by building upon other's efforts and not “not re-inventing any wheels.” This article summarizes the lessons I have learned as used-program salesman. Using this analogy, I will examine efforts made to institutionalize software reuse.
Article
This paper describes the experience of a large bank in designing and implementing an information systems strategy that is based on the concept of reusability. The design and implementation was performed in two stages: (1) building a prototype to investigate the feasability and attractiveness of reusability concept for the bank; and (2) its subsequent implementation using a library of reusable entities and a programmer's workbench. The implementation experience confirmed that applying the reusability concept to all stages of the system's life cycle results in both strategic (e.g., improving programmer productivity and increasing the bank's capacity for timely response to market opportunities) and operational (e.g., reducing and controlling system development and maintenance costs) benefits. It is estimated that the library of reusable entities embedded within the programmer workbench saved the bank over $1.5 million in development costs in 1989 alone. Two of the most important lessons learned in implementing the reusability-based strategy are: (1) reusability comes in many flavors and should be applied to all stages of systems life cycle; and (2) major challenges in implementing the reusability-based strategy are managerial, not technical.
Article
Manufacturers must accurately understand user needs in order to develop successful products-but the task is becoming steadily more difficult as user needs change more rapidly, and as firms increasingly seek to serve “markets of one.” User toolkits for innovation allow manufacturers to actually abandon their attempts to understand user needs in detail in favor of transferring need-related aspects of product and service development to users along with an appropriate toolkit.User toolkits for innovation are specific to given product or service type and to a specified production system. Within those general constraints, they give users real freedom to innovate, allowing them to develop their custom product via iterative trial-and-error. That is, users can create a preliminary design, simulate or prototype it, evaluate its functioning in their own use environment, and then iteratively improve it until satisfied. As the concept is evolving, toolkits guide the user to insure that the completed design can be produced on the intended production system without change.Pioneering applications in areas ranging from the development of custom integrated circuits to the development of custom foods show that user toolkits for innovation can be much more effective than traditional, manufacturer-based development methods.
Article
There has been a recent surge of interest in open source software development, which involves developers at many different locations and organizations sharing code to develop and refine programs. To an economist, the behavior of individual programmers and commercial companies engaged in open source projects is initially startling. This paper makes a preliminary exploration of the economics of open source software. We highlight the extent to which labor economics, especially the literature on 'career concerns', and industrial organization theory can explain many of these projects' features. We conclude by listing interesting research questions related to open source software.
Book
Why do some organizations learn at faster rates than others? Why do organizations "forget"? Could productivity gains acquired in one part of an organization be transferred to another? These are among the questions addressed in Organizational Learning: Creating, Retaining and Transferring Knowledge. Since its original publication in 1999, this book has set the standard for research and analysis in the field. This fully updated and expanded edition showcases the most current research and insights, featuring a new chapter that provides a theoretical framework for analyzing organizational learning and presents evidence about how the organizational context affects learning processes and outcomes. Drawing from a wide array of studies across the spectrum of management, economics, sociology, and psychology, Organizational Learning explores the dynamics of learning curves in organizations, with particular emphasis on how individuals and groups generate, share, reinforce, and sometimes forget knowledge. With an increased emphasis on service organizations, including healthcare, Linda Argote demonstrates that organizations vary dramatically in the rates at which they learn-with profound implications for productivity, performance, and managerial and strategic decision making. © Springer Science+Business Media New York 2013. All rights are reserved.
Article
Manufacturers must accurately understand user needs in order to develop successful products–but the task is becoming steadily more difficult as user needs change more rapidly, and as firms increasingly seek to serve “markets of one.” User toolkits for innovation allow manufacturers to actually abandon their attempts to understand user needs in detail in favor of transferring need-related aspects of product and service development to users along with an appropriate toolkit.User toolkits for innovation are specific to given product or service type and to a specified production system. Within those general constraints, they give users real freedom to innovate, allowing them to develop their custom product via iterative trial-and-error. That is, users can create a preliminary design, simulate or prototype it, evaluate its functioning in their own use environment, and then iteratively improve it until satisfied. As the concept is evolving, toolkits guide the user to insure that the completed design can be produced on the intended production system without change.Pioneering applications in areas ranging from the development of custom integrated circuits to the development of custom foods show that user toolkits for innovation can be much more effective than traditional, manufacturer-based development methods.
Book
This book presents a disciplined, qualitative exploration of case study methods by drawing from naturalistic, holistic, ethnographic, phenomenological and biographic research methods. Robert E. Stake uses and annotates an actual case study to answer such questions as: How is the case selected? How do you select the case which will maximize what can be learned? How can what is learned from one case be applied to another? How can what is learned from a case be interpreted? In addition, the book covers: the differences between quantitative and qualitative approaches; data-gathering including document review; coding, sorting and pattern analysis; the roles of the researcher; triangulation; and reporting.
Article
Information systems departments are being challenged to improve systems delivery performance. Software reuse is a potential strategy to address recurring systems development problems such as high development cost, low programmer productivity and long systems delivery lead time. However, the barriers associated with reuse implementation are significant. A better understanding of the administrative changes that facilitate reuse implementation is required to further research and practice in this area. We conceptualise reusability as a software process innovation that constitutes administrative and technological dimensions. Drawing from the synchronous innovation concepts, four theoretical models of the interrelationships between these dimensions of reusability and systems delivery performance are developed. Using the data collected through a postal survey these models are empirically evaluated. The results strongly suggest that administrative innovations intervene in the relationship between technological innovations and systems delivery performance and vice versa. This implies that synergies exists between administrative and technological dimensions of reusability which are more important in explaining variance in systems delivery performance than these dimensions individually. Implications of the study for IS theory, future research and practice are identified and discussed.
Article
Examines the correlation between the exploration of new possibilities and the exploitation of old certainties in organizational learning. Also discusses the difficulty in balancing resource management between gaining new information about alternatives to improve future returns (i.e., exploration) and using information currently available to improve present returns (i.e., exploitation). Two models which evaluate the formation and use of knowledge in organizations are developed. The first is a model of mutual learning in a closed system having fixed organizational membership and stability. The second is a model which considers the ways in which competitive advantage is affected by knowledge accumulation. The analysis indicates that the choice to rapidly develop exploitation over exploration might be effective in the short term, but is potentially detrimental to the firm in the long term. (SFL)
Article
In this paper we report on the results of a study of the effort and motivations of individuals to contributing to the creation of Free/Open Source software. We used a Web-based survey, administered to 684 software developers in 287 F/OSS projects, to learn what lies behind the effort put into such projects. Academic theorizing on individual motivations for participating in F/OSS projects has posited that external motivational factors in the form of extrinsic benefits (e.g.: better jobs, career advancement) are the main drivers of effort. We find in contrast, that enjoyment-based intrinsic motivation, namely how creative a person feels when working on the project, is the strongest and most pervasive driver. We also find that user need, intellectual stimulation derived from writing code, and improving programming skills are top motivators for project participation. A majority of our respondents are skilled and experienced professionals working in IT-related jobs, with approximately 40 percent being paid to participate in the F/OSS project.
Article
Systematic software reuse is a key business strategy that software managers can employ to dramatically improve their software development processes, to decrease time-to-market and costs, and to improve product quality. Effective reuse requires much more than just code and library technology. We have learned that careful consideration must be given to people, process, and technology. One approach to the systematic integration of these three elements is the concept of the software factory. At Hewlett-Packard Co., we have initiated a multifaceted corporate reuse program to help introduce the best practices of systematic reuse into the company, complemented by multidisciplinary research to investigate and develop better methods for domain-specific, reuse-based software engineering. This essay discusses our experiences. Key aspects include domain-specific kits, business modeling, organization design, and technology infrastructure for a flexible software factory.
Article
Reusable Software Libraries (RSLs) often form the core on an organizational reuse strategy. Although RSLs provide a place to deposit software for use by others, RSLs do not guarantee reuse success. The implementation of an RSL depends on many factors including the availability of quality and useful software. Domain-specific considerations most often determine the usefulness of software and therefore should influence how an organization populates an RSL. This article presents IBM's1 experiences with a corporate RSL, reuse incentive programs, and summarizes the results of an enterprise-wide initiative to develop reusable software for the RSL. The article explains some of the issues surrounding a large RSL and defines a three-phased progression typical of corporate reuse libraries.
Article
Despite the large number of successful software reuse cases reported, there are more than a few negative views that reuse has not yet delivered as expected. This is because of the lack of consensus on the applicative conditions of reuse technology and the size of the benefits that can be expected. This article describes a software reuse project conducted at Nippon Telegraph and Telephone Corporation (NTT) Software Laboratories. Based on this experience, the article discusses such important aspects of software reuse as domain selection and analysis, impediments, incentives, and library tools. It concludes that successful software reuse requires the selection of appropriate domains, systematic development of reusable modules based on domain analysis, and the commitment of senior management.
Article
Some very successful “open source” software products have been and are being developed, distributed, and supported in the field on a voluntary basis by and for users themselves — no supplier required2. The motives that induce users to contribute to an open source project “for free” and the mechanisms by which the various tasks can be effectively carried out are currently a subject of study for both practitioners and academics. To this point, explorations of the mechanics of and the incentives to participate in open source software projects have focused on the core tasks of developing and debugging and improving the open source software itself. Major motives used to explain why users would voluntarily work on these basic tasks include:1. a user’s direct need for the software and software improvements worked upon, 2. enjoyment of the work itself and 3. the enhanced reputation that may flow from making high-quality contributions to an open source project.
Article
The paper discusses three key economic problems raised by the emergence of Open Source: motivation, co-ordination, and diffusion. First, the movement took off through the activity of a community that did not follow profit motivations. Second, a hierarchical co-ordination emerged without proprietary rights. Third, Open Source systems diffused in environments dominated by proprietary standards. The paper shows that recent developments in the theory of diffusion of technologies with network externality may help to explain these phenomena. A simulation model based on heterogeneous agents is developed in order to identify the relevant factors in the diffusion of the technology.
Article
Software reuse is the use of software resources from all stages of the software development process in new applications. Given the high cost and difficulty of developing high-quality software, the idea of capitalizing on previous software investments is appealing. However, software reuse has not been as effective as expected and has not been very broadly or systematically used in industry. This paper surveys recent software-reuse research using a framework that helps identify and organize the many factors that must be considered to achieve the benefits of software reuse in practice. We argue that software reuse needs to be viewed in the context of a total systems approach that addresses a broad range of technical, economic, managerial, organizational, and legal issues and conclude with a summary of the major research issues in each of these areas.
Article
This paper represents a step toward a theory of knowledge reusability, with emphasis on knowledge ma nagement systems and repositories, often called organizational memory systems. Synthesis of evidence from a wide variety of sources suggests four distinct types of knowledge reuse situations according to the knowledge reuser and the purpose of knowledge reuse. The types involve shared work producers, who produce knowledge they later reuse, shared work practitioners, who reuse each other's knowledge contributions, expertise-seeking novices, and secondary knowledge miners. Each type of knowledge reuser has different requirements for knowledge repositories. Owing to how repositories are created, reusers' requirements often remain unmet. Repositories often require considerable rework to be useful for new reusers, but knowledge producers rarely have the resources and incentives to do a good job of repurposing knowledge. Solutions include careful use of incentives and human and technical intermediaries.
Article
This study was conducted to better understand the knowledge reuse process when radical innovation (e.g., experiments to prepare for human exploration of Mars) is expected. The research involved detailing the knowledge reuse process in six case studies varying in degree of innovation. Across the six cases, a six-stage reuse-for-innovation process was identified consisting of three major actions: reconceptualize the problem and approach, including deciding to search for others' ideas to reuse; search-and-evaluate others' ideas to reuse; and develop the selected idea. Findings include (1) the need for an insurmountable gap in performance to stimulate the decision to reuse others' knowledge; (2) the critical importance of an adapter to bridge the idea source and recipient; (3) three layers of search-and-evaluate activities in which the first layer of scanning to find ideas to reuse and the last layer of detailed analysis of ideas are bridged by a layer of brief evaluations of ideas assessing the presence (or absence) of targeted information about each idea; and (4) the differential use of metaknowledge about each idea to facilitate proceeding through each search-and-evaluate layer. In addition, reusers in the more (versus less) innovative cases redefined problems at the outset in nontraditional ways using analogies and extensions, rather than accepting the preexisting problem definition; used a substantially broader search strategy with a greater variety of search methods; and worked more closely with adapters during the latter stages of the reuse process.
Article
Open source software projects rely on the voluntary efforts of thousands of software developers, yet we know little about why developers choose to participate in this collective development process. This paper inductively derives a framework for understanding participation from the perspective of the individual software developer based on data from two software communities with different governance structures. In both communities, a need for software-related improvements drives initial participation. The majority of participants leave the community once their needs are met, however, a small subset remain involved. For this set of developers, motives evolve over time and participation becomes a hobby. These hobbyists are critical to the long-term viability of the software code: they take on tasks that might otherwise go undone and work to maintain the simplicity and modularity of the code. Governance structures affect the evolution of motives. Implications for firms interested in implementing "hybrid" strategies designed to combine the advantages of open source software development with proprietary ownership and control are discussed.
Article
Breaking with many established assumptions about how innovation ought to work, open source software projects offer eye-opening examples of novel innovation practices for students and practitioners in many fields. In this article we briefly review existing research on the open source phenomenon and discuss the utility of open source software research findings for many other fields. We categorize the research into three areas: motivations of open source software contributors; governance, organization, and the process of innovation in open source software projects; and competitive dynamics enforced by open source software. We introduce the articles in this special issue of Management Science on open source software, and show how each contributes insights to one or more of these areas.
Article
In this paper we propose that norms-based intellectual property (IP) systems exist today and are an important complement to or substitute for law-based IP systems. Norms-based IP systems, as we define them, operate entirely on the basis of implicit social norms that are held in common by members of a given community. Within that community, they offer functionality similar to contemporary law-based IP systems with respect to both the nature of rights protected and the effectiveness of the protection provided. We document the existence of a norms-based IP system among a sample of accomplished French chefs. These chefs consider recipes they develop to be a very valuable form of IP. At the same time, recipes are not a form of innovation that is effectively covered by law-based IP systems. Via grounded research, we identify three strong implicit social norms related to the protection of recipe IP. Via quantitative research, we find that accomplished chefs enforce these norms and apply them in ways that enhance their private economic returns from their recipe-related IP. In our discussion, we compare the attributes of norms-based and law-based IP systems, arguing that each has different advantages and drawbacks. We also point out that the existence of norms-based IP systems means that many information commons may prove to be criss-crossed by norms-based fences, with community access controlled by community IP owners.
Article
Abstract Reuse is widely promoted,as one of the most promising methods,for increasing productivity and quality within software development. Until recently most research into strategies for systematic reuse has focused on solution ,of the technical issues. Now ,as companies ,(mostly IT focused) implement the strategies developed, they find there are other issues which hold back their success, somewhat unrelated to the technical solutions offered. Reuse processes are not simple technologies and methods slotted into a development, like the transition in design notation from traditional approaches ,to an ,object-orientated method. , Whereas ,technology changes ,involve retraining developers. Reuse requires the whole organisation and funding of development,to be revised. If the magnitude ,of change ,involved ,in transitioning an ,IT organisation is so encompassing, where does this leave the rest of industry which is increasingly reliant on software to support their business process? This paper looks at organisational and management,issues raised by the introduction of software reuse to the development process. We identify inhibitors of reuse adoption, look at causes of these and suggest possible solutions. Aiming to concisely present all those non-technical issues that should be considered ,when ,introducing a reuse ,program. Considered ,also is how ,these issues affect companies which have IT in only a business support capacity, making this paper relevant throughout industry. 1
Article
Software reuse is being pursued in an attempt to improve programmer productivity. The concept of reuse is to permit various work products of software development to be used on more than one project in order to amortize their development costs. Productivity is not the only advantage of reuse although it is the most widely publicized. By incorporating reusable components into a new product, the components bring with them whatever qualities they possess, and these can contribute to the quality of the new product. This suggests that reuse might be exploited for achieving quality as an entirely separate goal from improving productivity. If useful properties pertaining to quality could be shown to be present in products as a direct result of software development based on reuse, this might be a cost-;effective way of achieving those qualities irrespective of the productivity advantages. The adjective certified is sometimes used to describe components that have been tested in some way prior to entry into a library but the term certified is not formally defined in the reuse literature. In this paper, we address the issue of certifying reusable components. We advocate the development of software by reuse with the specific intent of establishing as many of the required properties in the final product as possible by depending upon properties present in the reusable components. For this goal to succeed, a precise definition of certification of reusable components is required and such a definition is presented. The benefits of the definition and the way in which it supports the goal are explored.
Article
In this article we describe the importance of reusing software artifacts resulting from the earliest stages of the development life-;cycle, i.e., software conception, requirements analysis, feasibility study, requirements specification, architectural and detailed design. Although reuse of early artifacts is deemed beneficial to software development projects, there are no readily available software tools that could facilitate their effective reuse. Hence, we identified nearly one hundred early artifact types. We analyzed, compared and contrasted them. We clustered similar artifact types into distinct artifact affinity groups. We then proposed several methods and techniques useful in the processing of these artifacts to support their reuse. We believe that the proposed methods could be utilized by tool builders to construct software development environments capable of assisting analysts, designers, architects and programmers to effectively reuse the results of early life-;cycle activities.
Article
Growing competition in the investment bankingindustry has given rise to increasing demand forhigh functionality software applications that canbe developed in a short period of time. Yet deliveringsuch applications creates a bottleneck insoftware development activities. This dilemmacan be addressed when firms shift to developmentmethods that emphasize software reusability.This article examines the productivityimplications of object and repository-based integratedcomputer-aided software engineering(ICASE) software development in the context ofa major investment bank's information systemsstrategy. The strategy emphasizes softwarereusability. Our empirical results, based on datafrom 20 projects that delivered software for thebank's New Trades Processing Architecture(NTPA), indicate an order of magnitude gain insoftware development productivity and the importanceof reuse as a driver in realizing this result.In addition, results are presented on the extent of the learning that occurred over a two-year period after ICASE was introduced, and on the influence of the link between application characteristics and the ICASE tool set in achieving development performance. This work demonstratesthe viability of the firm's IS strategy andoffers new ideas for code reuse and softwaredevelopment productivity measurement that canbe applied in development environments that emphasizereuse.