Open Source as ESS

David Rysdam

In this document, I propose to take more seriously the analogy between the free-market (in particular the software market) and natural selection. A good way to do this somewhat rigorously is to use the notion of the ``evolutionarily stable strategy''. In order to accomplish this goal we must understand what an ESS is and how software licenses can be considered strategies.

As used in this paper, the term ``strategy'' comes from game theory. A quick example will help define things. Let's say A and B are playing the game chicken. In this game, two players race towards each other at high speed in cars. The person who swerves loses while the person who doesn't swerve wins. If both swerve, no one wins. If both don't swerve, needless to say, they both lose. To make this situation more clear let's put the strategies in a grid and assign numerical values to each outcome.



Swerve No Swerve
Swerve 0 -1
No Swerve 1 -10



This is a ``payoff matrix''. The rows are strategies open to Player A and the columns are strategies open to Player B. The values in the cells are the score that Player A will receive based on the strategies chosen by both A and B. (Note that they could equally well apply to B if we reassign dimensions). The values chosen are arbitrary but the relationships (-10 < -1 < 0 < 1) are not. Each of the numbered cells corresponds to one of these four statements:

1.
If we both swerve neither wins so the score remains 0.
2.
If you swerve and I don't, I win 1 point.
3.
If I swerve and you don't, I lose 1 point.
4.
If neither of us swerves, I will die and thus lose 10 points.
From this chart we can determine what our strategy should be. How? Well, it seems clear that the only way for A to get positive points is to choose the No Swerve strategy. But the same holds true for Player B. But both players choosing No Swerve would be disastrous (not to mention messy). So A, knowing that B will choose No Swerve can decide to minimize his own losses by choosing Swerve. This means he will get a -1, but since -10 < -1 this is a definite improvement. Of course, B is thinking the same thing. This second-guessing feature is what makes chicken so fun (for some people) but it also goes far beyond the scope of this paper.

Now we consider the idea of an ESS. All we do is take the above concept and iterate over a number of encounters. In other words, A and B play against each other many times. In fact, we have a large population of individuals that do nothing but mill around and play their strategies against one another. As they play, individuals will rack up points. The relative (not absolute) scores of these individuals determine whether they survive in the population. The ESS is the strategy that eventually comes to dominate the population. It is stable in the sense that individuals playing another strategy will do worse than individuals playing the ESS strategy.

There are mathematical methods for figuring out what this ESS is given tables like the above. Of course, there are complications such as mixed-strategies and situations for which no ESS exists but total extinction for everyone, but we aren't going to consider these, at least not in this draft.

Now let us consider software licenses as strategies. For the sake of brevity and clarity let us consider extremely (overly?) simplified licenses. A``typical'' license T, a generic open license O, and a version of the GPL G. Here are outlines of what each license contains1:

T:
Source code not available to other programs.
O:
Source able to be inspected and included in other programs at will.
G:
Source able to be inspected by all programs, but included only in other projects with G-type license.
Now let a software universe be populated by many programs that all perform essentially the same task and each use one of the above licenses as a strategy. Let's examine what happens during a few example encounters to get the feel for the idea.

And so forth. There are of course, nine possible interaction pairs but we can summarize with a payoff matrix as above. Let's say up front that being able to use your opponent's code is worth 10 but having your code used is -5. Thus, if you trade code for code with your opponent you both score 52.



T O G
T 0 10 0
O 0 5 0
G 0 10 5



The most obvious feature is that programs using strategy O are being ``preyed on'' by T and G. In the terminology of game theory they are ``suckers''3. The reason for this lies in the definition of strategy O. All players can examine and use code from O-strategy programs but O-strategy programs can only use code from other O's. That is, O-strategy programs cooperate well with each other, but do not keep ``predators'' from (ab)using them.

The next feature is that T-strategy programs are invulnerable to the predation that plagues the O's. Since they don't make source code available there is no danger of generosity being abused. On the other hand, this also negates the possibility of cooperation. T programs don't get killed off by others, therefore, but neither do they assist each other. This is the opposite of the O's.

The subtle feature is that G-strategy programs combine the best of both worlds. G's cooperate well because of the available source code but cannot be preyed on by non-G's because of the restriction of code usage to only G-type licenses. In other words, G's only cooperate with programs that are sure to cooperate back.

What does this mean for the long term (in our toy software universe)? Initially, T's and G's will grow rapidly fed by predation on O's. After a while, though, O's will become extinct as the average relative score of O programs becomes far lower than T's and G's. Once O's are gone the payoff matrix reduces to this:



T G
T 0 0
G 0 5



This payoff matrix is extremely simple and clear. Neither T's nor G's will gain off one another, but G's will edge out T's because G's cooperate while T's do not. Eventually T's will be extinct and all programs in the (toy) universe will have G-strategies.

There are many objections to be raised in opposition to this model. Some of those objections have been outlined here with answers to forestall argument.

Objection
T, O and G are more simple than real licenses.
Response
Nonetheless they do adequately serve to illustrate the ideas of license-as-strategy. And if we compare the predictions of even this model with the history of the software industry parallels will be found.
Objection
T, B and G do not represent all possible strategies. Each has sub-types and other basic types could be created.
Response
True. But I think we can agree that the strength of the G license is the combination of cooperation with the fending of off predation. At the very least we've shown that G is better than T. It may be that G will later be proven worse than X (the unknown future super-license).
Objection
This model assumes that all programs in the universe perform the same function. But there are many types of program from operating systems to word-processors to card games.
Response
It is sufficient to assume that all programs perform the same function, however. It is easy to see why. Say there were two types of software. Then we just make two model universes, one each for the types of programs that exist. That reduces the situation to the one described in this paper. The same can be done for any number of different program types. The reason this works is that software doesn't (normally) compete across types.
Objection
Programs of each type of license must be counted on not to cheat, at least not very much. For instance, if T programs incorporate code from G programs despite the license, T will gain some of the benefits of cooperation without paying the price of being open to predation.
Response
Even assuming no copyright protection laws, this is true only at first. As the G's begin to outweigh the T's in the universe, surviving T's will be looked on with more and more suspicion. People will ask ``How is it these T's survive without sharing source code?'' Soon it may be discovered that they do not. Another response hinges on the ongoing nature of cooperation. If a few lone T's were able to flout law and steal code this gain would be a single-shot act needing to be repeated over and over to keep working as the prey continued advancing.
Objection
If a universe filled with G licenses cannot be invaded by T licenses, how do we explain the growth of T licenses in the real world during the 1980's?
Response
The T licenses of the 80's were not invading a universe filled with G's. They were invading a universe of O's. We've already seen how open O's are to predation and indeed history indicates that many commercial software companies got their start by stealing publicly available (or at least not heavily guarded) code and selling it as their own.
Objection
What about the economics of the software industry? For instance, companies do what earns them money. T licenses offer a better chance to do that because they protect intellectual property.
Response
Companies can only make money off of programs that survive in the marketplace. A subtle point inherent in the above discussion is that the main beneficiary of a G license is the program that uses it. We all talk about how great it is when we have access to the source code of a program and we think of that as the reason for open licenses. But the payoff matrix indicates that the main advantage goes to the program itself. Once companies understand this concept of ``enlightened self-interest'' they will switch. And this understanding will be easy to come by once they see T licenses disappearing but competition remaining.
Objection
The payoff matrix assumes that, prior to the first round of comparisons, all programs are randomly distributed along the performance curve. That is, programs A and B chosen at random have equal chances of proving superior. This may not actually be the case in the real software universe. If instead, say, T license programs were, for whatever reason, consistently better than G and O license programs it wouldn't matter how much G's stole from O's or cooperated with other G's-they wouldn't be able to catch up to the T's.
Response
First, there is no reason to suppose that some license type L has consistently better programs. But say for the sake of argument that they were. It wouldn't matter. Software improvement isn't gained solely by predation-most of it is due to extra effort by the person or persons in charge. And that being the case, all that needs to be shown is that the programmers working on non-L programs are roughly equal to those working on L programs. Translating back to the real world, the question becomes ``Are GPL-using programmers roughly equal to proprietary-license programmers?'' The answer is obvious-many of these programmers are the same people!
Objection
One of the fundamental points of the above argument is that T's are non-cooperating predators. But in reality softare companies often work together to share ideas.
Response
That's absolutely true. But it takes a conscious act to cooperate among T's. With G's cooperation is automatic, making it more widespread. The power of G is the innateness of cooperation, with T's it's just tacked on the side.
So now we are prepared to answer a basic question that has been bandied about recently. Is Open Source Software the flavor of the month or is it The Real McCoy? OSS has been gaining ground rapidly and this paper provides a reasonably firm mathematical foundation for an explanation of why. The GPL (and equivalent) licenses, when considered as strategies, are simply better adapted to the free market. In other words, it is here to stay.

BfSf: Open_Source_come_strategia_evolutiva_stabile (last edited 2008-05-12 15:49:51 by localhost)