Elsevier

Research Policy

Volume 50, Issue 10, December 2021, 104349
Research Policy

The role of digital artefacts in early stages of distributed innovation processes

https://doi.org/10.1016/j.respol.2021.104349Get rights and content

Highlight

  • Uses Open Source Software as a setting to test hypotheses on distributed innovation.

  • Finds that presence of initial artefacts limits distributed contributors’ divergence in product representations.

  • Finds that initial artefacts work as a coordination mechanism, fostering project survival.

  • Tests the hypotheses with an original econometric technique on 5703 open source projects.

Abstract

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.

Introduction

The role of digital artefacts in distributed innovation processes is a central question in innovation studies, as digital technologies are becoming ubiquitous in the development of new products and services, raising questions and opening up unexplored opportunities for research and practice (Yoo et al., 2012; Lyytinen et al., 2016; Nambisan et al., 2017). In tackling those questions, scholars have conceived digital technologies as artefacts and considered the affordances they provide, i.e., ‘how the materiality of an object favours, shapes, or invites, and at the same time constrains, a set of specific uses’ (Zammuto et al., 2007: 752, Boland et al. 2007; Leonardi, 2010; Tiwana et al., 2010; Malhotra & Majchrzak, 2012; Majchrzak and Malhotra, 2019; Lee & Berente 2012; Majchrzak et al. 2013; Nambisan et al., 2017). Yoo et al. (2012: 1938), for example, argue that digital technologies ‘provide an environment of open and flexible affordances that are used in creating innovations characterized by … three traits: (1) the importance of digital technology platforms, (2) the emergence of distributed innovations, and (3) the prevalence of combinatorial innovation’. Such traits mostly derive from the fact that ‘the ‘new materiality’ afforded by digital technologies affects organizational and inter-organizational knowledge-related capabilities to innovate’ (Lyytinen et al., 2016: 50).

This paper contributes to this line of research by using the specific case of open-source software (OSS) development (OSS, Crowston et al., 2012) as a research context1. We investigate the impact of a digital artefact on the divergence of cognitive representations of software developers, i.e., ‘conceptual structures in individuals’ minds that encapsulate a simplified understanding of the reality these individuals face (Lakoff 1987; Thagard, 2014)’ (Gavetti & Warglien, 2015: 1267). Divergence of representations relates to representations being different from each other (Zuzul, 2019) and plays an important role for coordination of interacting individuals (Schelling, 1960; Clark, 1996; Puranam, 2018).

OSS represents a research context that is consistent with the three traits identified by Yoo et al. (2012): digital technologies are the fundamental means through which distributed actors coordinate, usually through online platforms (David & Rullani, 2008). Additionally, OSS project contributors are usually very heterogeneous (Rullani & Haefliger, 2013) and self-organise their distributed innovative work, so that OSS projects are characterised by exponential combinatorial outcomes. This implies that the coordination becomes a key challenge (Lanzara & Morner, 2005; Tiwana et al., 2010; von Krogh et al., 2012; Crowston et al., 2012; Lindberg et al., 2016). OSS development projects thus do not just represent a clear instantiation of the impact of the ‘new materiality’ (Lyytinen et al., 2016) of digital technologies on innovation processes: they also involve a particularly pronounced level of coordination complexity (Lindberg at al., 2016). Hence, they are a source of insight for the study of current distributed innovation processes more in general (Baldwin & von Hippel, 2011). Distributed innovation in open-source projects revolves around a digital artefact: software. Howison & Crowston (2014: 30) observe that prior research on virtual collaboration ‘has been concerned with characteristics of communication media, such as richness and synchrony, and fit with abstract aspects of task, such as certainty …, rather than specific characteristics of the artefacts being built.’ Such an omission represents a strong limitation of research on digital technologies because digital ‘artefacts …. define the social practices [that] are propagated in the organization’ (Rullani & Haefliger, 2013: 942). In other words, as the object of the innovation activity determines the possibility for ‘action’ during its production (Leonardi 2010), the software's material characteristics also shape coordination efforts and project outcomes.

Recent research taking this focus has provided a ‘theory of the open source way’ that gives centrality to the role of code release in a project (Howison & Crowston, 2014). It found that an important feature of software code is ‘superposition’, i.e., that ‘work proceeded in small, independent tasks, each with a functional pay-off through its changes to the codebase and thus the application. These changes layered on top of each other over time, each conceived and implemented for their own sake, yet simultaneously creating the circumstances taken as given for the production of the next layer in a way analogous to the superposition of rock strata’ (Howison & Crowston, 2014: 34). Howison & Crowston (2014: 31) argued that ‘[c]ollaboration through open superposition is at the core of the success of community-based OSS projects, allowing an organization of task work that leads to the discovery of a work-breakdown that is both motivating and surprisingly coordinated’. Howison and Crowston (2014) thus expand and reinforce the idea that artefacts, i.e., initial code and subsequent layers of code, have an impact on the development of distributed innovation projects that is different and distinct from how the project is organised (e.g. through leadership of virtual teams) and the characteristics of the code itself (e.g. modularity) (Bolici et al., 2016). We use this perspective to pursue the question how the software's material characteristics impact coordination efforts and project outcomes.

While ‘superposition’ has become a generally accepted theory in the analysis of OSS project development, we are left with two important empirical and theoretical gaps. First, there has been no empirical testing of the relationship between the existence of code at the beginning of a OSS project and its chances to deliver subsequent code releases, an important tenet of the superposition model. Medappa & Srivastava (2019) develop an inquiry along these lines, but their large-scale empirical study looks at how superposition influences the capability of OSS projects to engage a larger community of users, and not code production itself. Second, despite some intuitions (e.g. Dalle & David, 2005, 2008; Majchrzak & Malhotra, 2019; Majchrzak et al., 2021) the mechanisms through which such ‘layering’ of code through open superposition impacts project development is in many respects unknown. Howison and Crowston (2014: 42) theorise that ‘the forced constraints of community open source projects promote working in small layers, observed by others over time. This way of working generates an architecture that is more reusable, of higher quality, and more easily understood and which, therefore, tends to make deferred work easier over time, rather than harder.’ However, how such a layering process unfolds and the mechanism at work in producing the effect of making ‘deferred work easier over time’ is neither explained nor tested yet, leaving gaps in theory (Medappa & Srivastava, 2019). Consequently, we address the following the research question: Does initial code release increase the chance of project survival? And, what mechanisms link initial code release to project survival?

Building on theories on coordination in distributed OSS innovation (von Krogh et al., 2012; Crowston et al., 2012; Lindberg et al., 2016), on the properties of digital artefacts (Yoo et al., 2012; Lyytinen et al., 2016; Nambisan et al., 2017), and on how cognitive representations can facilitate coordination of innovation processes (Clark and Fujimoto, 1991; Schön, 1993; Seidel & O'Mahony, 2014), we focus on the role of cognitive representations (Lakoff 1987; Thagard, 2014; Gavetti & Levinthal, 2000; Gavetti & Warglien, 2015, Zuzul, 2019) in fostering coordination in OSS development (Puranam, 2018). We address our research questions by testing two hypotheses: (1) the presence of initial code release limits the divergence of team members’ representations and (2) limiting the divergence of team members’ representations triggered by initial code release implies a higher probability that the project survives, producing a subsequent code release. Divergence of representations relates to representations being different from each other (Zuzul, 2019). We use a dataset of 5,703 OSS projects registered on SourceForge.net during a two-year period. As we discuss below, the structure of the research question required a two-stage procedure: in the first stage, we verify that our hypothesised effect of initial code release actually manifests, limiting divergence of project contributors’ representations later on. In the second stage, we isolate the previous effect and test its ultimate impact on project survival, i.e. on whether the project subsequently releases code. We thus make sure not only that initial code release has an impact on project survival but also that this ultimate impact is due to the effect of limiting the divergence of contributors’ representations. The underlying logic underpinning our hypothesis development is that an early-stage version of the code – a digital artefact in our parlance – affects how contributors conceive of the project, limits the divergence of their representations, and, in turn, increases the chances of project survival.

Both hypotheses are supported. The interpretation we give to our results is twofold. First, as software development is a path-dependent process (e.g. Foss, Frederiksen & Rullani, 2016) where new layers of code are created on the basis of the existing code (Howison & Crowston, 2014), it is sensitive to initial conditions, and small events can have significant effects (Vergne & Durand, 2010; David, 1985; Arthur, 1989). Initial code shapes the initial conditions, exerting an important impact on the subsequent software development process. Second, because initial code is a digital artefact, it provides visibility (Bechky, 2003a, 2003b; Lanzara & Morner, 2005; West & O'Mahony, 2008; Okhuysen & Bechky, 2009; Howison & Crowston, 2014) of the architecture of the future code, its modules, interdependencies and interfaces. This sets the constraints and parameters of the project, which helps limit the divergence of team members’ representations, ultimately coordinating the distributed innovation activity (Seidel & O'Mahony, 2014).

The remainder of the paper is organised as follows. In Section 2, we prepare the ground by reviewing prior research on coordination in distributed innovation projects and the role played by artefacts. We also develop the hypotheses. Section 3 presents method and data; Section 4 the results. Section 5 identifies our contributions to theory and practice, including fruitful directions for expanding research and managerial solutions in many current forms of crowdsourcing and distributed innovation, where different kinds of artefacts play a similar role to initial code release when conventional coordination mechanisms such as modularity or leadership show some limitations.

Section snippets

Coordination in distributed OSS innovation projects

How to coordinate the actions of many individuals contributing to the design of a product is a well-established challenge in innovation research (Clark and Fujimoto, 1991; Dougherty, 1992, Brooks, 1995, Brown and Eisenhardt, 1995; Seidel & O'Mahony, 2014). Coordination of distributed innovation processes is especially challenging because of the vast number of search directions that individual innovators can take in a situation in which usual governance mechanisms either have limited capacity or

Data and main variables

Our analysis of the OSS context draws on data from the SourceForge platform, a standard data source in OSS studies (e.g. Comino et al., 2007; Krishnamurthy & Tripathi, 2009; Belenzon & Schankerman, 2015; Foss et al., 2016). We collected data on 5,703 projects registered on SourceForge from 15 January 2005, to 15 April 2005 that were still registered as ‘active’ in September 2006 and with at least one member in July 2005 and March 2006. Focusing on the mid 2000s allows observing the project's

Results

In the first stage of the regressions, the coefficients of Initial Codet0 are negative (-0.312 for the Negative Binomial and -0.251 for the Poisson) and significant at 1% level for both models. The provision of an initial piece of code thus leads to a decrease in the number of category changes during the course of the project. In the second stage, the coefficients of the predicted values of Category Changest1 are also significant, this time at 5%, and also negative (-0.775 and -0.711,

Discussion and conclusion

Does initial code release increase the chance of project survival? And, what mechanisms link initial code release to project survival? Our results show that the presence of initial code release in an OSS project has an impact on its chances of survival. We also argue that this is due to the fact that the provision of initial code limits the divergence of team members’ representations of the code to be developed, one cause of project failure. The following sections discuss how these results

Credits author

All authors, equally: Conceptualization, Writing - Original Draft, Writing - Review & Editing, Supervision, Project administration

Becker & Zirpoli equally: Although ideas have been developed together, the theory has been mainly developed by Becker & Zirpoli, equally. Specific roles: Investigation, Validation

Rullani: Although ideas have been developed together, the empirics has been mainly developed by Rullani. Specific roles: Funding Acquisition, Data curation, Formal analysis, Methodology

Declaration of Competing Interest

The authors declare that they have no known competing financial interests or personal relationships that could have appeared to influence the work reported in this paper.

References (114)

  • P.J. Aegerfalk et al.

    Outsourcing to an unknown workforce: exploring opensourcing as a global sourcing strategy

    MIS Q.

    (2008)
  • A. Afuah et al.

    Crowdsourcing as a solution to distant search

    Acad. Manage. Rev.

    (2012)
  • J.D. Angrist et al.

    Instrumental variables and the search for identification: from supply and demand to natural experiments

    J. Econ. Perspect.

    (2001)
  • J.D. Angrist et al.

    Identification of causal effects using instrumental variables

    J. Am. Statist. Assoc.

    (1996)
  • W.B. Arthur

    Competing technologies, increasing returns, and lock-in by historical events

    Econ. J.

    (1989)
  • C.Y. Baldwin et al.

    Design Rules: Volume 1. The Power of Modularity

    (2000)
  • C.Y. Baldwin et al.

    The architecture of participation: does code architecture mitigate free riding in the open source development model?

    Manag. Sci.

    (2006)
  • C. Baldwin et al.

    Modelling a paradigm shift: from producer innovation to user and open collaborative innovation

    Organ. Sci.

    (2011)
  • M. Barrett et al.

    Boundary object use in cross-cultural software development teams

    Hum. Relations

    (2010)
  • B.A. Bechky

    Object lessons: workplace artifacts as representations of occupational jurisdiction

    Am. J. Sociol.

    (2003)
  • B.A. Bechky

    Sharing meaning across occupational communities: the transformation of understanding on a production floor

    Organ. Sci.

    (2003)
  • M.C. Becker et al.

    How to avoid innovation competence loss in R&D outsourcing

    Calif. Manage. Rev.

    (2017)
  • S. Belenzon et al.

    Motivation and sorting of human capital in open innovation

    Strat. Manag. J.

    (2015)
  • R.J. Boland et al.

    Perspective making and perspective taking in communities of knowing

    Organ. Sci.

    (1995)
  • R.J. Boland et al.

    Wakes of innovation in project networks: the case of digital 3-D representations in architecture, engineering, and construction

    Organ. Sci.

    (2007)
  • K.J. Boudreau et al.

    Incentives and problem uncertainty in innovation contests: an empirical analysis

    Manag. Sci.

    (2011)
  • F.P. Brooks

    The Mythical Man-Month: Essays on Software Engineering

    (1995)
  • S.L. Brown et al.

    Product development: past research, present findings, and future directions

    Acad. Manage. Rev.

    (1995)
  • S. Brusoni et al.

    Knowledge specialization, organization coupling, and the boundaries of the firm: why do firms know more than they make?

    Adm. Sci. Q.

    (2001)
  • E. Cacciatori

    Resolving conflict in problem-solving: systems of artifacts in the development of new routines

    J. Manag. Stud.

    (2012)
  • P.R. Carlile

    A pragmatic view of knowledge and boundaries: boundary objects in new product development

    Organ. Sci.

    (2002)
  • C.E.H. Chua et al.

    Artifacts, actors, and interactions in the cross-project coordination practices of open-source communities

    J. Assoc. Inf. Syst.

    (2010)
  • H. Clark

    Using Language

    (1996)
  • Ki.m B. Clark et al.

    Product development performance

    Strategy, Organization and Management in the World Auto Industry

    (1991)
  • Colfer L., Baldwin C.Y. (2010) The Mirroring Hypothesis: Theory, Evidence and Exceptions, Working Paper No. 10- 058,...
  • K. Crowston et al.

    Coordination and collective mind in software requirements development

    IBM Syst. J.

    (1998)
  • K. Crowston et al.

    Free/Libre open-source software development: what we know and what we do not know

    ACM Comput. Surv.

    (2012)
  • Dabbish L., Stewart C., Tsay J., Herbsleb J.D. (2011) Social coding in GitHub: transparency and collaboration in an...
  • L. Dahlander et al.

    Progressing to the centre: coordinating project work

    Organ. Sci.

    (2011)
  • J.-M. Dalle et al.

    The allocation of software development resources in ‘open source’ production mode

  • J.-M. Dalle et al.

    Simulating code growth in Libre (open source) mode

  • Pa.ul A. David

    Clio and the economics of QWERTY

    Am. Econ. Rev.

    (1985)
  • P.A. David et al.

    Dynamics of innovation in an ‘open source’ collaboration environment: lurking, laboring and launching FLOSS projects on SourceForge

    Ind. Corp. Change

    (2008)
  • D. Dougherty

    Interpretive barriers to successful product innovation in large firms

    Organ. Sci.

    (1992)
  • Elliott M., Scacchi W. (2003) Free software developers as an occupational community: resolving conflicts and fostering...
  • S.K. Ethiraj et al.

    Modularity and innovation in complex systems

    Manag. Sci.

    (2004)
  • S. Faraj et al.

    Online community as space for knowledge flows

    Inf. Syst. Res.

    (2016)
  • M.S. Feldman et al.

    Reconceptualizing organizational routines as a source of flexibility and change

    Adm. Sci. Q.

    (2003)
  • B. Fitzgerald

    The transformation of open source software

    MIS Q.

    (2005)
  • N. Foss et al.

    Problem-formulation and problem-solving in selforganized communities: how modes of communication shape project behaviors in the free open source software community

    Strat. Manag. J.

    (2016)
  • View full text