🚀 go-pugleaf

In <3641@airs.com> ian@airs.com (Ian Lance Taylor) writes:
> Jim Adcock once suggested (in private e-mail) a useful perspective.
> There are three types of people who care about the GPL:
> 
>     1) Tool and library creators, such as the FSF.
>     2) Software integrators, who take tools and put them together
>        into integrated products.
>     3) Software users who take tools and use them.
[...]
> mathew@mantis.co.uk (who seems to be currently naming himself after a
> bypass) is complaining about the GPL from the perspective of a
> category 2 person.  He wants to integrate GPL'ed software with his own
> software to produce a new product which he will release on his own
> terms.  He claims to not understand why the GPL prevents him from
> taking this action.

No, you've got the wrong end of the stick.

I want to write packages which call existing GNU stuff to perform
whatever functions the GNU stuff performs.  If this involves improving
the GNU stuff, I'm quite happy to make those improvements "free".  What
I don't see is why my code which calls the GNU stuff should have to
be "free" as well.

For example, suppose I create a complete version control system which happens
to use GNU tar for creating archives of old versions.  First of all, does
the GPL cover my program if it calls a standalone GNU tar?  The FSF answer
seems to be "hire expensive lawyers".  What about if I provide .o files
and get the user to link during installation?  What about if I build the
GNU tar code into my code for efficiency?

Bear in mind when considering this hypothetical example that whatever I
ended up doing, I would be quite happy to distribute GNU tar with complete
sources, plus any enhancements or bug-fixes I made, all under the GPL. 
I just wouldn't be willing to place the entire version control system under
the GPL.

Now, it strikes me that if the FSF is going to try and take an "all or nothing"
approach and (in this case) force me to make the VCS "free" if I am to be
allowed to use GNU tar, then the FSF is actually damaging the cause of free
software.  Here I am, offering to ship people GNU tar, fix bugs in it,
improve the code, and distribute all the GNU tar code "freely" to everyone, but
that's not good enough because I happen to use GNU tar as an 'engine' to
produce archive files in some completely different non-"free" application.

I mean, I could write my own archiver.  But isn't it better that I use a
standard format like tar format that people can get "free" software to use?
Isn't it better that I spend my time working on GNU tar, improving it and
fixing bugs and distributing those improvements "freely"?

Although this is a hypothetical example, it is not a million miles away
from a real situation I find myself in.

> (Let me digress and point out the obvious, which other people have
> probably mentioned as well.  mathew could release his code as a bundle
> of new code and a shell script which patched the GPL'ed code to use
> his new code.  His code and shell script could be distributed under
> any terms whatsoever, but would, of course, require a copy of the
> GPL'ed code to be useful.  However, he apparently does not find this
> satisfactory).

Actually, it probably is satisfactory in a sense, but I have problems with
it.

Firstly, it seems to be contrary to what the FSF wants; and believe it or
not, I'm not out to screw the FSF as much as possible.  I'd much rather
come to an agreement with them than have to use subterfuge to get around
their license.

Secondly, it's not certain whether the course of action you suggest would
get around the problem.  Again, the FSF answer seems to be "get some
expensive lawyers".

[ Good personal reasons deleted ]
> Therefore, I think every person should have access to source code for
> programs that they use.

YOU THINK.  Note that.

I'm not arguing that nobody needs source code.  I'm arguing that many people
don't WANT source code.  I would much rather get a "hoarded" compiler from
Borland for #40 and rely on Borland to fix the bugs at their expense,
rather than spending hours, days or maybe even weeks having to fix the bugs
myself or pay Cygnus to do it.  It's cheaper for me.  It may not be cheaper
for the hundreds of people I'm not allowed to give the "hoarded" compiler
to, but I'm not overly concerned with that.

Of course, I may end up getting stuck with bugs.  Therefore I'm careful
to buy products which I know are reasonably bug-free, and from manufacturers
whom I know will actually attempt to fix bugs.

Now, you may personally have decided differently.  That's your choice. 
And CHOICE is the key word.  I think it should be up to the user to choose
whether he wants to buy a "hoarded" product or copy a "free" one.

The FSF disagrees.  It aims to eliminate "hoarding" of software.  ALL
hoarding of software, not just hoarding of FSF software.  Contrast this
with the big companies, who by and large do not want to eliminate all "free"
software (although they don't want some of their code becoming "free").

Another difference comes when I make use of someone else's code in my program.
For example, when I link my C++ program with someone's libaries, or use
some source code for a useful utility or sample program as a tiny bit of my
program.

The FSF says that when I do that, my code becomes theirs.  The commercial
companies do not (in general) make similar claims.

> Therefore, I am aware of the danger of allowing anybody to
> redistribute my code without source: the user, the category 3 person,
> might wind up with a product that is less useful than the one I want
> to provide.

But the user CHOSE that product.  Why don't you spend your time offering
him a better alternative, rather than trying to force everyone to release
source "freely"?

If what the FSF claims is right -- if free software is really better than
hoarded software -- then free software should be able to win just by being
better.  People won't buy hoarded software, because they'll recognize that
free software is so much better.  Eventually, there'll be no market for
hoarded software.

If you don't believe me, look at what happened to copy protection.  People
bought software without screwy disk formats in preference to software with
screwy disk formats.  Now very few packages have stupid copy protection
systems.

Why can't we do the same for source code?


mathew

-- 
Hail Eris! / "Our whole economy's based on fear and death; how long can we get
away with this?" --- Jello Biafra / Message for Kodak: Bring back Dan Bredy! /
PGP RSA public key available on request / Desperately seeking Negativland's U2
CD / Just another would-be Mac owner put off by Apple's monopolistic practices