Statue1 of "freedom",
by Thomas Crawford

Building a Democratic Company


23 January, 2001

Democracy is more than just raw voting. For a democracy to endure, four conditions need to be met.

  1. The proper constituency has to be gathered up.
  2. An appropriate constitution, with checks and balances, needs to be instituted.
  3. A good deliberation mechanism needs to be put in place, to allow for the rational proposal and resolution of issues.
  4. An efficient voting mechanism is needed.


We are still on condition 1. The most important thing that we are doing is gathering up people who believe in, and understand, `free software'. Just like you wouldn't let the former Soviet people vote in American elections, we need to make sure that we define the constituency to have the right people who share our free software ideals.

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.


A major protection of free software that must exist in the constitution is that all code is required to be released under the GPL License. The next most important requirement is that an appropriate system of checks and balances needs to be instituted, so that power is shared sufficiently broadly so that no single person, or small clique, is able to centralize power unto themselves and subjugate everyone else.

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.


An appropriate deliberation system to raise, rationally discuss, and resolve issues is already being developed using a knowledge-tree structure. This is an important project, because it is the foundation for any rational voting system.


Any voting software has to have some fundamental properties, without which it is not possible to guarantee the correctness of the polls.

These are:

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.


used atop the dome of the US Capitol building, Washington D.C.

HTML generated using LaTeX2HTML
by Ross Moore, 2022-02-06 for FD-PublicRelations