The Role of Modularity in Free/Open Source Software Development

Software design and development in Free/Open Source projects are analyzed through the lens of the theory of modularity applied to complex systems. We show that both the architecture of the artifacts (software) and the organization of the projects benefited from the paradigm of modularity in an original and effective manner. In particular, our analysis on empirical evidence suggests that three main shortcuts to modular design have been introduced and effectively applied. First, some successful projects inherited previously existing modular architecture, rather than designing new modular systems from scratch. Second, popular modular systems, like GNU/Linux kernel, evolved from an initial integrated structure through a process of evolutionary adaptation. Third, the development of modular software took advantage of the violation of one fundamental rule of modularity, that is, information hiding. Through these three routines, the projects can exploit the benefits of modularity, such as concurrent engineering, division of labor, decentralized and parallel development; at the same time, these routines lessen some of the problems posed by the design of modular architectures, namely imperfect decompositions of interdependent components. Implications and extensions of Free/Open Source projects experience are discussed in the conclusions. 701 E. Chocolate Avenue, Suite 200, Hershey PA 17033-1240, USA Tel: 717/533-8845; Fax 717/533-8661; URL-http://www.idea-group.com ITB10129 IDEA GROUP PUBLISHING This chapter appears in the book, Free/Open Source Software Development, edited by Stefan Koch. Copyright © 2005, Idea Group Inc. Copying or distributing in print or electronic forms without written permission of Idea Group Inc. is prohibited. The Role of Modularity in Free/Open Source Software Development 85 Copyright © 2005, Idea Group Inc. Copying or distributing in print or electronic forms without written permission of Idea Group Inc. is prohibited. INTRODUCTION In this chapter we argue that modularity, a well-known paradigm for the design and the production of complex artifacts (Schilling, 2000), is a key element in explaining the development and the success of many Free/Open Source (F/OSS) projects, since it offers a comprehensive explanation of many key issues, such as how division of labor takes place between developers, how coordination is achieved, how code testing and integration is deployed and how innovation occurs. Our reconsideration of the accounts of many F/OSS projects highlights how they benefited from the typical advantages of implementing modular architectures (e.g., fast speed of development, recombination of modules, innovation through projects competition, reuse of previously developed code) (Feller & Fitzgerald, 2000; Hatch, 2001; Jackson, 1998), while, at the same time, many critical pitfalls typically related to managing modularity (the architectural design of modules and interfaces) were avoided. Three interrelated strategies, or design shortcuts, appear to have been particularly effective in this respect. First of all, the architectural guidelines of many complex systems were clearly inherited from previously existing modular software projects (see, for instance, the GNU project and the FreeBSD project, which closely resemble the UNIX architecture). By imitating a well-established architecture, developers were able to avoid the problems related to the design of modular architectures from scratch, namely, devising a decomposition of the whole system in independent sub-parts or modules (as we will see further on, this is not a trivial task). Secondly, when devising modular architectures that are considerably innovative, it is not possible to rely on blueprints of existing software; in such cases, another design shortcut is to think of modularity not in terms of a static and ex-ante design principle but, rather, as a dynamic activity of problem solving that starts from fairly interconnected architectures that are repeatedly fine-tuned and reworked, leading over time to more modular outcomes (“evolving modularization”). In this respect, we found it useful to analyze the evolution of the GNU/Linux kernel. Conversely, pursuing full modularity from the beginning may be very risky, and may eventually lead to serious difficulties (as in the case of the development of the HURD microkernel). Finally, F/OSS development style seems to suggest a third effective design shortcut. While information hiding has been traditionally viewed as the key principle guiding both the design and the implementation of modular software artifacts, F/OSS seems to substantially disregard this principle at the implementation level. For instance, empirical evidence shows that F/OSS developers systematically improve parts of the project on which they are working by tinkering with the code of multiple modules, taking advantage of the source availability and of the absence of code ownership. Our examination is based on published and unpublished data: interviews and papers written by key actors, analyses developed by scholars, and quite a large mass of original documents made available through Internet websites. 17 more pages are available in the full version of this document, which may be purchased using the "Add to Cart" button on the product's webpage: www.igi-global.com/chapter/role-modularity-free-opensource/18721?camid=4v1 This title is available in InfoSci-Books, InfoSci-Software Technologies, Science, Engineering, and Information Technology, InfoSci-Select, InfoSci-Computer Science and Information Technology. Recommend this product to your librarian: www.igi-global.com/e-resources/libraryrecommendation/?id=1