Mason Loring Bliss <mason@acheron.middleboro.ma.us> writes:
> I'm not talking about standards being bad. I'm saying that folks are seeing
> the chafe between competitive commercialism and the open source philosophy.
> The idea of competitive commercialism is to be successful, and you end up
> becoming successful by having that which your competitors lack. This does
> not have good synergy with a philosophy that says that you should share
> what you have out of the goodness of your heart to make the world a better
> place.

I completely disagree, on two grounds.

1) I do not share code out of the goodness of my heart or out of a
desire to help mankind. I share because I get something out of sharing
-- personal satisfaction and, at times wider use of my code (which is
often valuable to me). Were I not enjoying what I was doing, I would
not do it, even if I felt the activity was of benefit to our species
as a whole.

2) It is known that you can make money in the Open Source world. You
just make it off of things other than selling software itself -- such
as the selling of services. The fact that I might have something that
my competitors lack (i.e. skill at writing new code that people hire
me to write) does not mean that there is any conflict at all with my
code becoming open source. It would only be a conflict if my revenue
model was the same as Microsofts, instead of, say, the same as Cygnus's.

> > People can benefit from the sharing of standard tools, without giving up
> > their advantages.
> 
> Right. But the advantages of the tools != the competitive advantage of having
> good tools that you don't share with others, such that they're forced to use
> less-good tools.

Empirical economic and other studies have shown that the naive
assumption (that cooperation is not to the benefit of a competing
organism) is not true. A winning strategy for the individual organism
competing with others is a combination of non-cooperative and
cooperative behaviors.

In other words, simply because I might gain some temporary advantage
over you by not trading resources with you doesn't mean it is of real
long term advantage to me -- the division of labor, among other
things, means that I gain substantial advantages by engaging in
trade.

Or, to put it in capitalist hacker terms, I can't afford to develop my 
own toolchain and operating system -- I have product to get out. By
cooperating on the toolchain and operating system, I gain a much
greater advantage than attempting (in vain) to produce a superior
proprietary one would give me. Part of this is because the advantage
to me of a proprietary toolchain is microscopic and the resources
expended tremendous. Part of this is because I do better attempting to 
exploit my comparative advantage than attempting to do all things
(which is econ 101).

> The BSD and X licenses are just as good, IMHO, with the one exception being
> that folks who wish to make the code proprietary may do so. I see little
> value in this, personally. In every sense, BSD and X licensed code is just
> as free as GPLed code once you have it - there's simply no guarantee that
> you'll be able to get the code.

The BSD license has substantial advantages for the capitalist hacker,
however. As an example, say I want to use NetBSD in an embedded
automated doorbell. It is substantially better for me not to have to
deal with the pain in the neck of making my doorbell software
available for years to all comers -- completely ignoring the question
of whether competitors would gain an advantage, it is a *supreme pain
in the buttocks*, and *my customers almost certainly don't care*.

Now, I would almost certainly integrate my code into the source tree
so that I'd get the benefits of others working to keep my code up to
date -- in return, the minority that is interested and knows what they 
are doing will probably hack new versions of my doorbell
system. However, I have been protected from dealing with the utter
annoyance of preserving every version of my code I ever release and
dealing with people calling up requesting it until the end of time.

The BSD license has lots of other advantages as well. It makes it
clear that I can pretty much do what I like with the code. The only
problem with it is the advertising clause, which I'm starting to take
out of my own code.

The GPL vs the BSD license has another feature to it as well. The GPL
is essentially paternalist in approach. It says "you must share this
code". The BSD license is much more to my (literally) anarchist
viewpoint. It says "you are stupid if you don't share this code, but
we do not restrict your freedom even to the extent of telling you
whether or not you must share, too. If you want to be a fool, go right
ahead."

I think some lessons are best learned, not imposed. When I was a kid,
foolish adults attempted at times to inculcate lessons of life
experience they had learned into me, as though such experience was
transferable. Some things, however, must be learned on one's own. Most
things can't be "taught" paternalistically. Math, for instance, can't
be "taught". At best, a teacher can present information for a
student in a coherent framework so the student can follow the path
much faster than the people who took 3000 years to find it took, but
if the teacher tries to "ram the information in", the student learns
nothing -- the student can only learn by going through the problems
himself and seeing the pattern with his own brain.

Similarly, the GPL tries to impose, paternalistically, the notion of
hacker community and the value of cooperation over unenlightened
anti-cooperative behavior. The lesson is accurate, but it cannot be
learned this way. The outsiders to the community must learn on their
own why it is that in this instance the community is in their own
personal interests, and not some sort of "the many over the one"
communism, and that lesson must be learned by *doing*, not from
outside themselves. 

The BSD license, by contrast, produces the situation in which the
experiment may be tried and the student can learn. BSDI can try to
"take the code proprietary" and lose the race, even though, as Kolstad
once "observed", they can copy any of our code they want at any
time. People can try to sell products filled with code that originated
in BSDworld and discover the magic isn't in the code itself but in the 
community that built it.

Furthermore, Paternalism is inflexible. As I noted, in the name of
imposing the lesson, the teacher also guarantees that even in idiotic
cases the price of openness must be paid.

Perry