nemesis <nam### [at] gmailcom> wrote:
> >   I like how GPL fanboys resort to argue about semantics when their "you
> > can use it in any way you want" is proven wrong. Suddenly the term "use"
> > is limited to certain uses, not all of them. Thus, of course, this is a
> > self-contained truth: "GPL code can be used for anything you want, when
> > we define 'use' appropriately."
>
> Using the software is not the same as using the source of the software.
>   That's really where your "semantic" gets skewed.
>
> You can't use the source unmodified as the basis for your software
> without making the larger work a derivative and you can't modify the
> source without release the changes under the GPL as well.  That's the
> only 2 restrictions of the GPL and they don't cover *usage* of the
> software, which *is* unrestricted for any purposes.
>
> There's no fanboyism, just logic.

There's a problem with this logic, lying in the definition of "use".

If I develop an application by modifying an existing one, I'm definitely using
source code. No argument here.

If I develop an application that "uses" a certain library by statically linking
to it - am I *using* the source code here, or am I rather *using* the library
via its well-defined interface?

If I recompile the library and then link it into my binary, the question is
quite clear: I *am* using the source code, because otherwise I couldn't
recompile it. And If I distribute my software in binary format, the question is
rather moot anyway, as I agree that in this case the whole binary can easily be
seen as a single work, of which the library is an inseparable part. After all,
it's one single file.

Now what if I develop an application that "uses" a certain library by
*dynamically* linking to it?

Obviously I'm no longer using the *source code* here - except for the header
files; it can be argued whether these are merely a formal description of the
library API, or part of the library source code, but in the latter case I could
still re-write the header files from scratch according to the API.

So am I not in fact just *using* the software, instead of developing a
derivative work?

What if I don't distribute the library along with my application, and instead
advise the user to get them somewhere else?

What if my application links the library in a way that it will still run if it
isn't present on the target system?

In all these cases, I see GPL still claiming rights on my application by *their*
definition of "derivative work".

However, where's the borderline between this and, say, *using* the API of an
operating system? The command line interface of another application? An
application installed somewhere else in the world-wide web?

It's all a question of borderline, and I think the FSF's interpretation of this
borderline is in itself "borderline", if not already *far* beyond.

Post a reply to this message