Felix Stalder on Wed, 12 Dec 2001 18:39:01 +0100 (CET)

[Date Prev] [Date Next] [Thread Prev] [Thread Next] [Date Index] [Thread Index]

[Nettime-bold] Re: <nettime> The Fading Altruism of Open Source Development

I never understood why people think of Open Source in terms of _altruism_.
Perhaps, it's due to some confusion related to the "saintly" image of
Richard Stallman, but it's the completely wrong approach and shows a very
limited understanding of economic relationships where things are more
varied than than selling things vs giving them away.

To make a long argument short, altruism is, if anything, the effect of Open
Source but not its cause. For Open Source to work, people do not need to be
altruistic, or at least not all of them. As far as I can see, many of the
developers who contribute to Open Source do so in the context of their
professional work, be it as members of academic institutions -- where
publishing and visibility has nothing to do with altruism but is a
necessity of survival -- or in the context of companies who use and extend
Open Source software in the work they do for clients.

But let's forget for a moment software and look at another great Open
Source project: the law. Nobody would claim lawyers as a profession to be
altruistic, even though there are certainly individuals with altruistic
motives. Many of them are highly paid and some are very much motivated by
money. Nevertheless, they all contribute to a great Open Source project.
The law and the court proceedings (ie. the code) are public and if you
want, you can use an argument made in one case by someone else in your own
case. In fact, this is standard practice and crucial to the efficient
working of the legal system. This is how the system learns and evolves and
how it avoids to be clogged with an endless numbers of identical cases. If
lawyers could copyright their arguments (i.e. restrict other lawyers from
using them), the system would break down, particularly the Anglo-American
system of common law.

In some ways, creating the law is similar to creating software. The first
copy (i.e. deciding the first case in a new area) tends to be very
expensive, but subsequent copies (i.e. deciding further similar cases) are
much cheaper.

The problem -- and the reason why lawyers make a good living -- is that
there are rarely identical cases, or, at the very least, it is very hard to
tell if a case is identical to one that has already passed through system.
What you pay a lawyer for is her knowlegde of the relevant cases and her
work to take whatever necessary from them and then customize it for your
own context and needs. Sometimes this "customization" is relatively
trivial, sometime this includes a significant contribution to the evolving
public knowledge base.

To some degree, the same model applies to Open Source Software development.
What you pay, say, IBM for when they install a new server with Linux on it,
is the service they provide to you for customizing what is out there (Linux
etc.) to your own ideosynractic needs. And rarely, your needs are exactly
the same than other people's needs.

Many people who contribute to Open Source Software work in contexts that
produce software but don't sell it. Be it that they are academics/students
or be it that they sell services. Taking from and contributing to free code
is in both cases a strategy that makes sense for very "selfish" reasons,
even though they also contribute to the free knowledge base.

Les faits sont faits.

Nettime-bold mailing list