A Work In Progress
Introduction
One of the classic themes in economics is the Crises of the Commons. The Crises of the Commons dates to the Middle Ages, and refers to commonly held fields around towns. These fields were owned by the town and were available to everyone. Since they were available to everyone, it was in each individuals best interest to use the commons to graze their cattle. Since they were not required to pay for or maintain the commons, it was in their best personal interest to use the commons without helping to preserve or maintain them. The result was massive over-grazing of the commons, which resulted in a barren wasteland of no benefit to anyone.
The Crises of the Commons is used to describe any situation where resources are available at no direct cost, producing a local optimization of using the resource without providing anything back, resulting in the destruction of the shared resource. This is sometimes called the freeloader challenge, where people take without giving back. Common ways to avoid freeloaders include personal ownership, where it is in the individuals best interest to maintain the resource, or renting the resource, where consumption has a cost. The rental model both moderates demand and provides a mechanism to pay for maintenance of the resource.
Open Source Software (OSS) turns this model on its head, producing a Cornucopia of the Commons. OSS isn't free – it simply doesn't have a purchase price. Despite this, OSS has a strong, pragmatic economic model. This model is based on a combination of shared resources, communities of interest, “barter”, and value added offerings. A separate essay will address methods for monetization of OSS.
This essay describes the economic model of OSS that produces this cornucopia and how it avoids the crises.
Managing the Commons
There are three key elements to consider:
-
Software is not consumable – it has infinite supply and zero cost.
-
The GPL resolves the freeloader challenge through an ingenious use of copyright.
-
The software elements that are consumable – support, enhancement, and running the software, have feedback mechanisms that manage freeloaders and provide a familiar economic foundation.
Software Consumption
Software has, in economic terms, a marginal cost approximating zero. That is, the cost of producing the n+1 unit of software is essentially equal to zero. Note that this is only true for pure software – the bits. Other elements of software, such as physical media, physical documentation, and support, do have significant marginal costs. However, the underlying software is essentially free.
In addition to having zero marginal cost, software is non consumptive – use of software does not consume that software. When someone makes a copy of software, the original copy is not affected. It still has all of its original attributes and values. In fact, an infinite number of copies of a piece of software can be made and used without altering or consuming the original product. Thus, in contrast to physical products which can be consumed and used up, software has infinite supply and can be consumed with no loss.
This means that software has no inherent limitation on use.
Traditional economic models assign a marginal cost to production of products, and state that the price of a product will converge on this marginal cost. Since software has essentially no marginal cost, it can be inferred that the marginal price should approach zero.
Note that we are considering marginal cost. Software certainly has development cost. Normally these development costs are amortized into the marginal costs, using a variety of cost models. One of the greatest novelties of OSS is that it has the ability to replace the amortization model with a community based shared resource model that uses what can be considered a barter approach. In other words, payment in kind instead of payment in cash. We will examine this in more detail later.
Addressing Freeloading Through the GPL
Although software has a marginal cost of zero and the bits can be used up, they can be consumed in other ways. This can happen through people taking OSS, changing it or adding to it, and delivering this new enhanced software as a traditional product where people have to pay to receive the enhancements (as well as the original software). This has the effect of taking resources from the commons and making them private property. In other words, freeloading by taking the common resource and providing nothing in return for it.
Over time, this could result in proprietary products built on OSS that are better than the original OSS offering.
The foundation of OSS – and the reason for its economic viability, is the Gnu Public License (GPL) created by Richard Stallman. The master copy of the GPL can be found at www.gnu.org/licenses/gpl.html.
The GPL takes copyright and turns it on its head. Where copyright is traditionally used to restrict distribution, the GPL specifically allows anyone to use, modify, and redistribute GPL software – provided that they pass on these rights to the original software and any modifications. Anyone can use GPL software for any purpose, make as many copies as they want, and change it in any way they desire. The only requirement is that they have to redistribute these rights anytime they redistribute the software.
The result is a mechanism for maintaining the commons. GPL is free to use, free to fix, and free to enhance. The GPL avoids freeloaders by allowing people to use the software for any purpose without charge (why not, the marginal cost is zero), but requiring improvements to be returned to the common good.
This is a great economic model for software developers – they get to build on a foundation of thousands of man-years of software development at no charge. They will be adding small amounts of code to millions of lines of existing code to get exactly what they need. This is a great model for hardware vendors, who get the benefit of a robust operating system for the cost of enabling it to work with their hardware (by providing drivers under the GPL). This is a great model for OSS, creating a virtuous circle where each addition of new code increases the value of the software for everyone. This is a great model for users, who receive high quality software for “free”.
The result is that where OSS software exists, that software becomes a commodity. When a product becomes a commodity, companies can respond by reducing their price to a commodity level, differentiating their product, or experiencing a loss in market share. In many cases companies respond by trying to prevent their product from becoming a commodity; this is seldom successful.
Community
While the GPL is the major enabling factor for OSS, the thriving OSS world that we know today is a result of a phenomena known as The Community. The Community is the organization, implementation and execution of software built on the GPL. Where proprietary software comes from an identifiable corporation, OSS software comes from a loosely knit collection of corporations, foundations, groups, organizations and individuals who are working together and interacting in an informal structure of cooperation, competition and happy conflict. It is a model much closer to political organizations than corporations. It requires reaching agreement among multiple parties through influence, rather than the command and control structure of corporations – think city government rather than General Motors.