23 January, 2001Democracy is more than just raw voting. For a democracy to endure, four conditions need to be met.
I believe that we are most vulnerable to takeover at the earliest stages. In later stages, with an established strong base of adamant free software developers, and with an appropriately framed constitution with the right protections of GPL code, we will be less vulnerable to usurpation. It will always be a risk however, even later, because dividing developers and making code proprietary will always be a temptation for some would-be tyrants. But with the GPL requirement written into the constitution, an attempt to close the code will be blatant and obvious; thus allowing those who believe in free software to mobilize an appropriate defense. Even if the organization succumbs to non-believers, all of the released code will be GPL'd. The true believers can start the whole process again, in a different organization, building upon all of the experience garnered from the failed attempt.
In all scenarios, the reasoning depends on a sufficient number of true believers of free software. But with the inherent logic of free software (that empowers and enfranchises developers with a more efficient development model), the expectation is that once the world is given a successful precedent, via a free and democratic software company that pays developers competitively with proprietary companies, the superiority of free software will convince an overwhelming majority of developers that this is the better way. Therefore they will fight for it, and will resist attempts to return to a proprietary age.
But first we need to gather up the true believers.
Since power by nature tends to centralize over time, we need to initially build a structure that puts as much power as possible at the edges. This will establish a precedent that later can be used to resist the natural inclination people will have for a strong centralized leader--the constant drum beat for a benevolent dictator--to deal with inevitable crises that always arise in any organization.
How do we do this? Think of the founding of the American democracy. The United States of America started with separate States. Starting with states allowed those who wanted to have a decentralized constitutional system to plead for powerful state governments, instead of a powerful centralized national government. They thereby pushed the power to the edges as much as possible.
We should do the same. FreeDevelopers should be thought of as an organization of United Free Software Projects of the World. It is the projects which should be the basic units of power, not FreeDevelopers itself.
FreeDevelopers should be constructed as an oversight structure, to ensure that no single project and project leader becomes so powerful that it conquers and subjugates the rest. (Remember how MS-DOS was leveraged into Windows, which was leveraged to ensure that Internet Explorer succeeded.)
FreeDevelopers need only allow for a loosely-coupled, central structure to deal with project-to-developer relationships and project-to-project relationships. This is to ensure that developers, or other projects, are not abused by powerful project leaders.
By concentrating the power on the projects, it decentralizes power generally. This allows us to experiment with different democratic constitutions in the projects, to see which are the most efficient and fair.
We should be starting projects, and starting to create model democratic constitutions for those projects. At this point, project constitutions are important but not crucial, because so long as the code is GPL, no project leader can become too powerful at this point, before an appropriate constitution is put into place. Thus the coding can be started right-away, as soon as appropriate projects are proposed, and leaders come forward to lead them.
In an online community like FreeDevelopers, which consists of people who have never seen one another, these requirements are more difficult to achieve. The key to getting these right is the selection of fool-proof voting protocols. Voting protocols are the rules by which the software receives, checks and registers the votes. We are already in the process of developing one such protocol, and currently are giving finishing touches to this protocol.