EXPLORING THE KNOWLEDGE CREATING COMMUNITIES

EXPLORING THE KNOWLEDGE CREATING COMMUNITIES:
AN ANALYSIS OF THE LINUX KERNEL DEVELOPER COMMUNITY
HAOXIANG XIA*
Institute of Systems Engineering, Dalian University of Technology, No.2, Linggong Road
Dalian, 116024 China
E-mail: hxxia@dlut.edu.cn
SHUANGLING LUO and TAKETOSHI YOSHIDA
Graduate School of Knowledge Science, Japan Advanced Institute of Science and Technology
Nomi, Ishikawa 923-1292, Japan
E-mails: {slluo, yoshida} @jaist.ac.jp
The knowledge creation processes and activities in online communities become prominent in our society, with the proliferation of all sorts of online communities. This phenomenon brings enormous challenging research issues. In this paper, we give an in-depth analysis on an actual case of the Linux kernel developer community, to illustrate that such community is essentially an evolutionary collective-intelligent system; and this system grows through the spontaneous self-organization processes. This work may pave the way for further theoretical exploration of the knowledge-creation processes in online communities; and on the other hand it has practical implications for developing computing technologies to facilitate the development of the “knowledge-creating communities”.
1. Introduction
In the last decades, the growing significance of knowledge to the social and economic development of our society has attracted tremendous efforts on “Knowledge Management” (e.g. Nonaka & Takeuchi 1995; Alavi & Leidner 2001). These efforts generally set the focus on studying the knowledge systems inside the boundary of a formal organization like a business company, a governmental department, and an academic institute. However, many knowledge activities and processes are beyond the institutional boundaries. One noteworthy phenomenon is that the online communities, which have been proliferated with the explosive development of the Internet and the Web, have become a prominent vehicle for knowledge creation, dissemination and utilization. The knowledge processes in these online communities are fundamentally different from those in a formal organization. The knowledge creation, dissemination and utilization in an online community are basically accomplished by independent contributors or participants in a self-organizing and “autopoietic” fashion, while in the formal organization these knowledge processes usually take place under the centralized managerial control to achieve some well-defined organizational objectives. Therefore, the theories and models for organizational knowledge management cannot be simply transplanted to study the knowledge activities and processes in the online communities. The studies on the knowledge activities and processes in an online community would be a challenging issue; and at the same time they are both of theoretical value to examine a type of knowledge systems that are critically different from the firm-based knowledge systems, and of practical value to enhance the knowledge production and utilization in our society.
One noteworthy knowledge-intensive online community is the Linux kernel developer community. The Linux Kernel is the operating system kernel that underpins all distributions of Linux operating systems. It was initiated by Linus Torvalds in 1991 as an open-source software (OSS) project. Linux is one of the most fascinating success-stories of the OSS movement. Moreover, it is fascinating that the Linux Kernel is primarily developed by thousands of part-time voluntary programmers scattered across the Internet without formal organization or centralized control. Along with the development of the Linux Kernel, an online community of the contributors, or the Linux Kernel developer community, rapidly grows. Due to the miraculous success of Linux, it would be worthwhile to examine how the collective actions of the voluntary contributors develop such large-scaled and complex software of high quality without centralized coordination. As software development can be regarded as one form of knowledge creation, this examination is from another aspect to explore the knowledge creation in the loosely-connected online communities of independent participants.
Therefore, in this paper we try to explore such “knowledge-creating” online communities by giving an analysis on the actual case of the Linux-kernel developer community (LDC for short). In an earlier effort, we suggested that many online communities manifest some degree of community intelligence (Xia et al. 2008; Luo et al 2009). Following that view of community intelligence, we try to explore the underlying dynamics for the evolution of the LDC as well as the development of this community’s knowledge product, the Linux kernel.
2. A Short History of the Linux-kernel Developer Community
To facilitate further discussion, the history of Linux is shortly introduced, with the focus being placed on the growth of the developer community in which the Linux kernel is collectively created and continually updated.
Linux was initially developed by Linus Torvalds in 1991, when he was a student in computer science at University of Helsinki. His initial motivation was to write programs in order to use some UNIX functions in his own PC with an 80386 processor; and he implemented a task-switching program, a disk driver and a small file system, which constituted Linux 0.01. On 25 August 1991, he announced this skeletal operating system in the newsgroup “comp.os.minix” and asked for suggestions for the preferable features. Then, his continuous efforts ended up to Linux 0.02, which came on October 5th. Together with the free release of the source code, he posted another message in the same newsgroup to seek feedbacks as well as possible contributors or co-developers. This was a critical event for Linux since it started the collective journey of Linux development. The response was instantly positive; of the first ten people to download Linux, five sent back bug fixes, code improvements, and new features. By the end of the year, when Linux finally became a stand-alone system in Version 0.11, more than a hundred people worldwide had joined the Linux newsgroup and the mailing list (Kurabawa 2000). Since then, the Linux developer community rapidly expands, together with the rapid development of the Linux operation system.
One critical measure is the development of the Linux kernel in term of the source lines of code (SLOC). The actual SLOCs in some typical versions are listed in Table 1. This table shows that the Linux kernel rapidly expands in the past 18 years.

Table 1 Growth of SLOC in Linux Kernel (Some Typical Versions)
(Data Source from: Wikipedia article on “Linux Kernel”, available at: http://simple.wikipedia.org/wiki/Linux_kernel)
Release Year Kernel Version Source Lines of Code
1991 Linux 0.0.1 10,239
1994 Linux 1.0.0 176,250
1996 Linux 1.2.0 310,950
1999 Linux 2.2.0 1,800,847
2001 Linux 2.4.0 2,210,149
2003 Linux 2.6.0 5,929,913
2008 Linux 2.6.25 9,232,484

Another critical measure for the growth of the LDC is to count the community size. Since its creation in 1991, this open operating system has attracted increasing numbers of developers worldwide. In the year of 1993, there were over 100 developers worked on the Linux Kernel. More recently, as reported by Koah-Hatman et al. (2008), each release since version 2.6.11 generally contains the work of nearly 1000 developers. Since 2005, about 3700 individual developers have contributed to the kernel. Their report also shows that the number of developers gradually increases from 483 in Version 2.6.11 to 1057 in Version 2.6.24.
The previous description reveals much information for the LDC. Linux had a somewhat haphazard starting-up, since Torvalds himself was not even aware that he was writing an operating system when he began programming the first task-switching system in 1991. He did not anticipate at that time that Linux would catch such persistent enthusiasms from so many developers and users, nor could he imagine that Linux would become such huge and complex software and such a successful product. From this haphazard starting-up, the community rapidly develops together with the explosion of the Linux (kernel) product. Behind the success of the Linux operating system and the growth of the Linux developer community, two questions naturally come to the fore: what are the underlying dynamics of the evolution of this Linux developer community; and why this huge and complex software product can be successfully created in this largely open community without thorough planning or centralized control.

3. Some Previous Views on the LDC
The intriguing phenomena of the Linux operating system and the corresponding developer community have attracted great attention in the last decade. Here we just give a short description on a few typical views.
One well-noted work is given by Raymond (1999), who distinguished two different styles of software development, i.e. the “cathedral” model of most of the commercial world and the “bazaar” model of the Linux world. The success of the Linux project is then attributed to the inherent openness in the bazaar model. On one hand, Raymond believes one success factor of Linux is the frequent releasing and updating so that the users can quickly detect the bugs; one the other, with a large developer base, the project leader Linus Torvalds can safely rely on others to write and test the code for him. The openness is for sure an important factor for enhancing Linux development; however, it is farfetched to use the openness to explain everything.
Kuwabara (2000), by contrast, argued that the bazaar-analogy is too simplistic, and the success of the Linux project should be understood from an evolution and complex-adaptive-system (CAS) point of view. To him, behind the Linux project is a bottom-up engineering approach that effectively challenges the top-down worldview entrenched in the monolithic software engineering approach. We largely agree with his CAS view; our further argument is that the Linux developer community is not merely an evolutionary system, but also an evolutionary intelligent system. Another drawback of Kuwabara’s work is that he points out that the Linux project should be considered as a CAS, but the underlying mechanisms of the formation of this CAS is not well-addressed.
Iannacci (2005), in his PhD dissertation, gave a social epistemological analysis for the LDC. The major focus is on the coordination mechanisms that are emerged in the community. Three mechanisms are analyzed in his work, namely standardization, loose-coupling to form a “heterachical” structure, and partisan mutual adjustment. Lee and Cole (2003), from the knowledge-creation perspective, attempted to develop a community-based model of knowledge creation, adopting the evolutionary framework suggested by Campbell (1960) and emphasizing the role of criticism and critical evaluation as a key driver in the evolutionary processes.
The prior endeavors, among many others, contribute to enrich our understandings of the knowledge-creating online communities in general, and the Linux kernel developer community in particular. However, their work reflects the partial facts of the LDC from different facets; more inquiries are still needed to achieve a more comprehensive view.
4. The LDC as an Evolving Communal-Intelligent System
Based on the prior observations of the LDC development and the current work on explaining the LDC phenomena, in this section we give our analysis on the LDC, basically regarding this community as an evolutionary collective-intelligent system in which the participants collectively create knowledge and solve problems. On one hand, the collective knowledge work around the development of the Linux operating system is the most fundamental driving-force of the community; on the other hand, the most apparent way to measure the evolution of this community is to observe the growth of its primary knowledge product (i.e. the Linux system). Thus, the development of this LDC largely reflects the phenomenon of community intelligence, as conceived in the authors’ earlier work (Xia et al. 2008, Luo et al. 2009). Subsequently, we try to explain the evolution of the LDC from the aspect of community intelligence; and we hope this analysis would in turn enrich our understanding of the nature of community intelligence.
4.1. The LDC as a Bottom-up and Evolutionary Knowledge-Creating Community
The starting point of our analysis is that the LDC is a bottom-up and evolutionary “knowledge-creating” community. This view furthermore contains two points.
First, in the LDC the knowledge-creation is the primary action that fundamentally impels the community development. Furthermore, in this community the knowledge creation is conceptually comprised of two categories of actions, namely knowledge-building and knowledge-networking. The reason of the existence of the Linux developer community is that the participants collectively and collaboratively develop Linux. This is inherently a knowledge-building process and what is built is basically represented as the Linux source code and annotations, as well as the related documentations. Therefore, this knowledge-building process persists as Linux development continues and the LDC exists. At the same time, knowledge networking among the participants or contributors ubiquitously takes place throughout such knowledge-building. One basic means of knowledge networking is through the instant discussions within the community. In the LDC, the contributors have dense discussions with one another, primarily via the Linux-kernel mailing list. Through such discussions, large amount of technical knowledge spreads; and simultaneously, the contributors may also improve their “know-who” knowledge, together with the development of an implicit reputation system within the community. The knowledge networking can also take place in an indirect way. In this way, one may learn from other contributors’ patches and bug-fixes; and knowledge transfer happens. In short, the knowledge building and knowledge networking generally constitute the overall process of the knowledge-system evolution in the entire community.
Second, the evolution of the communal knowledge system is not a monolithic process, corresponding to the “bottom-up” engineering of Linux development as Kuwabara contends. Linux is developed by thousands of independent programmers without complete goal-setting, thorough planning, or top-down task-assignment. As stated, when Torvalds initially announced Version 0.01 in 1991, he himself had no clear intention for the future of Linux; and he just asked for feedbacks and suggestions on the features which Linux should contain. During the entire process of Linux development, he also avoids imposing long-term plans and visions on the community:
“That way I can more easily deal with anything new that comes up without having pre-conceptions of how I should deal with it. My only long-range plan has been and still is just the very general plan of making Linux better.” (Interview, cited from Kuwabara 2000)
Instead, the stage-goals of development usually rise from collective efforts and discussions. Unlike a formally-organized software project, neither Torvalds nor any other sub-system maintainer authoritatively arranges a particular contributor to accomplish a particular task. From the very beginning, it has been left to each contributor to decide what to work on at the moment:
“In developing Linux, you have complete freedom to do whatever you feel like doing. There's no specification anywhere of what the Linux kernel has to end up doing, and as such there is no requirement for anyone to do anything they are not interested in.” (Personal Interview, cited from Kuwabara 2000)
Thus, the entire project is carried out in a spontaneous mode without global coordination. In the project, nobody can anticipate what will be added or modified in the next release of the Linux kernel. Associated with this spontaneous and bottom-up development of the Linux operating system is the endogenous growth of the corresponding community of the developers. This LDC again grows from bottom up as the result of the free choices of the contributors. No one can exactly anticipate who will join the community by submitting patches and bug-fits at the next stage of work, or who will leave because of any reason. Without formal organization, up to now this community has somehow stabilized to be an effective community that efficiently creates complex software of high quality.
4.2. An Exploration of the Underlying Dynamics of the LDC Evolution
Following the previous view of the LDC, we can try to explore the underlying dynamics. The basic observation is that there are dense communications within the Linux developer community; and these communications play a critical role in programming the Linux kernel and in the development of the LDC itself. The Linux-kernel mailing list is the central discussion forum for the developers. In the later 1990s the kernel traffic has reached up to six megabytes of posts in a week, according to a report by Zack Brown, (cited from Kuwabara 2000). In another research, Lee & Cole (2003) counted the total number of emails sent to the mailing list during 1995 to 2000. They found that 14,535 people had sent at least one e-mail to the mailing list; and each person has averagely sent 14 emails over 5 years, since there were 199,374 emails archived as of August 26, 2000.
It can be argued that these communications, which are mostly localized, serve as the micro-foundation of the evolution of the entire LDC and of the creation of Linux. These localized communications activate some self-organization processes so that they eventually enable the macro-level evolution of the entire community.
First of all, coordination is doubtlessly critical to the quality of Linux as well as to the development of the community. Without coordination, the integrity of the Linux product would not be possible, nor could the developer community grow to be a coherent or creative one. However, as the contributors have complete freedom to do whatever they like to do, the top-down coordination is generally absent in this community. Instead, coordination in the LDC is an emergent property generated from bottom up. One simplest case of coordination is the task “assignment” (tasks not assigned really, as the tasks are voluntarily done). For one contributor, the good performance in his past work reinforces his reputation and trustworthiness for the quality of his other contributions. Such coordination is indeed activated by the indirect communications. The contributor transfers knowledge by submitting the patches; and other community members simultaneously get “know-who” knowledge when obtaining the technical knowledge related to the submitted patch. As a result, such indirect knowledge communication impels possible future collective and collaborative work.
More direct technical communications are also pervasive in the LDC, basically via the Linux-kernel mailing-list. Randomly picking up a thread from the mailing-list archive, we often see intensive discussions on some particular technical problem. For example, Michael Zick reported a bug-fix on May 22nd, 2009 by posting the following message:
“Found in the bit-rot for 32-bit, x86, Uni-processor builds:
…
Submitted: M. S. Zick” (Source: Linux-kernel mailing list, archived at: http://lkml.indiana.edu/hypermail/linux/kernel/0905.2/02562.html)
Immediately, this message causes intensive discussion. Under this thread, there were 31 postings on that same day. At least 6 persons participated. Among them, Zick posted 13 messages, Andi Klein posted 4, Ingo Molnar posted 1, Peter Anvin posted 4, Samuel Thibault posted 4, Dreier posted 2, and there are 3 other anonymous postings (probably posted by the above-listed authors too). This is a common scenario of the technical discussions in the Linux kernel developer community. It is not unusual that such technical discussions give rise to the emergent collaborations among the participants. Iannacci (2005) terms this kind of coordination as “partisan mutual adjustment” and argues that collaboration teams or “social networks” may appear from such communications. These social networks are open to contributions from everybody. However, they usually contain strong ties among a limited number of participants because of their frequent interactions; and a stable core may form around the strongly-tied participants.
Besides facilitating the formation and adjustments of the collaborative teams or networks, the coordination through discussions also plays a critical role in the advancement of the overall Linux kernel project. Kuwabara mentioned an example of the row I/O patch, submitted by Stephen Tweedle in 1998 and rejected by Torvalds several times before the final version was at last applied into the kernel. In the example, an iteratively-improved technical solution was achieved by collective work of the involved developers coordinated through communications.
From the prior description, we can perceive that the emergent coordination is a key element that makes order grow from chaos in the LDC, as through such coordination the structuring of collaborative teams or networks takes place and the patches with good quality are often the result of the coordinated work.
Closely related to the emergent coordination is the evolution of an implicit reputation system underlying the LDC. It is the common case that the highly-reputed or trusted persons play a central role in the communications and collaborations. They often become the primary coordinators (e.g. sub-system maintainers) in many collective efforts. However, their reputations are, in turn, the result of the performances of their previous contributions in submitting patches and in the discussions.
Kuwabara (2000) describes a feedback process for the self-reinforcement of the individual reputation, as shown in the following figure.

In this process, the reputation of an individual increases according to the contributions he or she makes; and in turn, the increasing of his or her reputation may foster the further contributions from the same individual. Kuwabara uses such reinforcement process to explain the motivations for a community member to contribute. We argue that this process also has influences to the evolution of the community itself. With the increasing reputation, an individual may play an increasingly-important role in the development actions; thus the evolution of the implicit reputation system is a critical factor for the formation and adjustment of the overall structure of the community.
From another aspect, the communications also stimulate “stigmergic” processes (Theraulaz & Bonabeau 1999). The stigmergic processes basically function through the technical building of the Linux system. As previously cited from the project leader Linus Torvalds’ assertion, “my only long-range plan has been and still is just the very general plan of making Linux better”, the global goal-setting and long-range planning are absent in developing Linux. Moreover, the development of Linux is the collective work of massive autonomous contributors who also lack global sight of the project. With these two essential features, the development of Linux is the collective architecting without blueprint, resembling the nest-construction activities in the insect societies such as the termite colonies. Thus, it is natural to suppose that the stigmergic processes may exist in the Linux developer community, analogous to the collective nest-construction in a termite colony. Following this analogy, the general situation of Linux development is that the contributors decide what to do in terms of what they have done. Therefore, no one, including Torvalds, knows in advance what would be added or modified in the next release; and the overall development is always open-ended. But during this open-ended process, their product is increasingly complex, increasingly powerful, and increasingly fitted to the environment (i.e. to better satisfy user needs and to cope with the technology advances outside the Linux project).
Generally, there are two sources to stimulate the stigmergic interactions. One situation is the amplification of some personal ideas and suggestions inside the community. Another situation is the adaptation to environmental or external changes, especially technological innovations outside the Linux project.
Responding to the internal and the external “stimuli”, some member(s) may trigger a stigmergic process in the community, acting like a termite emits pheromones onto a site to call for other termites to continue building there. Such a stigmergic process is generally a self-reinforcement process. If one ongoing topic is active and intriguing, and if it brings many open challenges, many contributors would be attracted to this topic; and more progresses may be made, bringing even more amount of further open issues…Gradually, when the “constructing” on this topic is going to complete, the contributors may step away because there is not so much work left.
Bringing the previous discussions together, we can tell that the self-organizing processes around the emergent coordination, the evolving reputation system and the stigmergic interactions in constructing the software system shape the overall process of the evolution of the LDC. Thus the emergence of the global properties can be examined in the next part of this section.
4.3. The Overall Evolution as Emergent Global Property
We contend that the entire Linux developer community manifests high collective intelligence. Such community intelligence is firstly and most-remarkably represented by the Linux operating system itself. Today the Linux kernel has become an extremely complex software system containing over 9 million source lines of code. Building such a system looks like a mission impossible to a collectivity of part-time hackers without any formal organization, as it is difficult task even for the largest corporations. The efficiency and effectiveness in the building of the Linux system have unquestionably proved the high “intelligence” of this online community. Kroah-Hatman et al. (2008) showed the rate of change of Linux kernel from Version 2.6.11 to 2.6.24, as depicted below.

Fig.2. Rate of Change of Linux Kernel from Version 2.6.11 -2.6.24
According to Figure 2, on average within 100 days the community announces a new stable release, which contains thousands of pieces of changes from the previous release. This figure convincingly illustrates the highly-efficient work done by the Linux developer community. For the effectiveness of the Linux contributors’ work, it is difficult to get direct quantitative measurement; but the complexity of the system on one hand, and the adoption rate on the other hand have illustrated the effectiveness of their development.
In addition to the external measurement of the efficiency and effectiveness of the development work, the global regularity of the LDC can also been seen internally. As the internal measure, two properties are shortly discussed here, i.e. the global structuring of the community and the emergence of the norms of code quality and coding style.
One global consequence of the previously-discussed self-organization processes is the formation and evolution of the community structure. Most remarkably, a hierarchical structure gradually forms during the evolution of the community. This structure was described by Kroah-Hatman in his 2008 presentation at Google, as shown in Figure 3.

This hierarchical structure is actually a core-periphery structure. In this structure, the project leader Torvalds works closely with a limited number of lieutenants. They are core developers and subsystem maintainers. The peripheral participants are the ad hoc patch-submitters and bug-reporters. Torvalds himself explained this structure in a post:
“The fact is, we've had "patch penguins" pretty much forever, and they are called subsystem maintainers. They maintain their own subsystem, ie people like David Miller (networking), Kai Germaschewski (ISDN), Greg KH (USB), Ben Collins (firewire), Al Viro (VFS), Andrew Morton (ext3), Ingo Molnar (scheduler), Jeff Garzik (network drivers) etc etc. …
A word of warning: good maintainers are hard to find. Getting more of them helps, but at some point it can actually be more useful to help the _existing_ ones. I've got about ten-twenty people I really trust, and quite frankly, the way people work is hardcoded in our DNA. Nobody "really trusts" hundreds of people. The way to make these things scale out more is to increase the network of trust not by trying to push it on me, but by making it more of a _network_, not a star-topology around me.” (Source: Linux Kernel Mailing List Archive, at: http://lkml.indiana.edu/hypermail/linux/kernel/0201.3/1070.html)

In this post, Torvalds clearly stated that the structuring of the community relies on a “network of trust”. He himself trusts a small number people in the “inner circle” or the subsystem maintainers, and each maintainer trusts a small number of other developers, and so on… This network of trust is in fact the implicit reputation system underlying the community. Correspondingly, the evolution of this reputation system generally directs the adjustment of this working structure of the community. In short, the overall structure of the Linux developer community is emergent instead of organized top-down; and the subsystem maintainers grow, instead of being officially assigned. This structure is furthermore flexible. An active contributor who performs well in his previous contributions may play an increasingly vital role in the community; by contrast, if one contributor becomes less active, he might gradually become the peripheral participants.
Another measure is the formation of the global norms in the community. With the growth of the community, the formats of submitting patches and reporting-bugs become standardized. The standards on the code quality and the coding styles are also enforced. An example given by Kuwabara (2000) is the Italian programmer Andreas Arcangeli’s patches for the printer code:
“[Arcangeli] made substantial improvements, then branched out, but tended to do some pretty sloppy things - to the point where Linus said "go away." Andreas refused to go away, and eventually had major changes to the kernel accepted. All Linus did was enforce coding standards.” (Personal Interview 1999, cited from Kuwabara 2000)

At the first glimpse, it looks like that this standardization attributes to the personal efforts of Torvalds and his close co-developers. But factually it is the result of the coordination of the entire community. Without the abundant base of contributors, this standardization is impossible; without the adoption of the standards by the contributors, this standardization is either impossible. In turn, this standardization is a means of the emergent coordination of the whole community; and the accepted norms or standards are actually become a proportion of the communal knowledge.
To sum up, according to the prior analysis we can claim that the view of evolutionary community intelligence facilitates to explain, at least partially, the development of the LDC and the success of the Linux kernel project. On the other hand, this LDC also provides an excellent actual case to enrich our understandings on the knowledge system developments in online communities.
5. Conclusion
In this work, we give an in-depth analysis on the actual case of the Linux kernel developer community, to illustrate that such community is essentially an evolutionary collective-intelligent system; and this system grows through the spontaneous self-organization processes. This work may pave the way for further theoretical exploration of the knowledge-creation processes in online communities; and on the other hand it has practical implications for developing computing technologies to facilitate the development of the “knowledge-creating communities”.
References
Alavi, M. & Leidner, D. (2001) “Knowledge Management and Knowledge Management Systems”, MIS Quarterly, 25(1):107-136.
Campbell D. T. (1960) “Blind Variation and Selective Retention in Creative Thought as in Other Knowledge Processes”, Psychology Review, 67:380-400.
Iannacci F. (2005) The Social Epistemology of Open Source Software Development: The Linux Case Study. Ph.D. Dissertation, University of London.
Kroah-Hatman G., Corbet J., McPherson A. (2008) “How Fast it is Going, Who is Doing It, What They are Doing, and Who is Sponsoring It”, Report at the Linux Foundation.
Kuwabara K. (2000) “Linux: A Bazaar at the Edge of Chaos”, First Monday, 5(3). at: http://firstmonday.org/htbin/cgiwrap/bin/ojs/index.php/fm/article/view/1482/1397
Lee G. K. & Cole R.E. (2003) “From a Firm-based to a Community-based Model of Knowledge Creation: The Case of Linux Kernel Development”, Organization Science, 14(6): 633-649.
Luo, S., Xia H., Yoshida T. & Wang Z. (2009) “Toward Collective Intelligence of Online Communities: A Primitive Conceptual Model”, Journal of Systems Science and Systems Engineering, 18(2): 203-221.
Nonaka, I. & Takeuchi, H. (1995) The Knowledge Creating Company: How Japanese Companies Create the Dynamics of Innovation. Oxford: Oxford University Press.
Raymond R. (1999). “The Cathedral and the Bazaar”. Knowledge, Technology & Policy, 12(3): 22-49.
Theraulaz G., Bonabeau E., (1999) “A Brief History of Stigmergy”, Artificial Life 5:97-116
Xia H., Wang Z., Luo S., and Yoshida T., (2008) “Toward a Concept of Community Intelligence: A View on Knowledge Sharing and Fusion in Web-mediated Communities”, In: Proceedings of the 2008 IEEE International Conference on Systems, Man, and Cybernetics, Singapore, 2008. pp.88-93, IEEE Press.