Did I finally figure out the rationale?

[mike3]

Hi.

I notice this post apparently fell on deaf ears, and I'd like to make
it more
visible as I'm wondering if I finally figured out the whole GNU
License thing:

---
> Imaging for a second that you have a work, to which you add some
> non-free code.  A user can no longer change the work as a whole, since
> parts of it are not free.  The GPL sees that an evil part cannot do
> such things.  It simply does not make anything free, it just sees that
> the a free program stays free.



Oh, becuase the modified program (even if the vast majority of said
"modified" program's code is not GPL to begin with -- it's still
considered
a "modified" program) cannot then be free, only the original program,
however the modified program is still considered a version of the
original
and therefore still possesses the attribute of being free if it still
has any
part of the original left, even if 99.99% of it's code has been
totally
changed and expanded as to be unrecognizable -- that 0.01% still
means
it is the GPL program. Because the incorporation of GPL code _can_
be viewed as a modification of the original if we imagine the process
not as taking a piece from the GPL program and *adding* it to our
original work, but instead as *removing* all code except what we want
to use *from the GPL program*, and then adding in all our *original*
work,
even if this would be quite a stretch of the word "modify" in
colloquial
terms, which often does not mean a change to the majority of
something
so as to make it nigh indistinguishable.

However, since we are discussing *source code* not functionality,
Even if the functionality and outward appearance of the program is
*totally* different from the GPL one if it still includes GPL code
"left over"
*in the source code* it is still a modified version. It is only
considered a
new program when *zero* GPL code remains and hence the GPL no
longer covers it (provided we haven't released the program already --
we're talking about during it's creation here.), as it is then
totally,
completely ours (ie. 100% original).

---


Another post had this:

---

> I think that's a stretch. Most of the folks here have been using the
> phrase "to ensure that free code remains free". I hear your thinking
> that if you start with a free component A and extend it to create a
> blended component A+B, where B is proprietary, that the blended
> component has no impact on the "freeness" of A. But it does. A+B can be
> structured so that it both improves upon A and is incompatible with A.
> It's a tactic called embrace and extend. Now you have A+B, which doesn't
> have the same rights as A. You must purchase B. You cannot modify/extend or
> redistribute B. You cannot fix B. A+B is now non free even though A is
> free. And A can easily be locked out of the usage loop by A+B.



Why would one have to purchase B? A still retains it's original
functionality without B. You'd only need to purchase B if A
was somehow made dependent on B, which it is not.

What if it _is_ compatible with A, then what?



> But B cannot exist without A. So what has happened is that an originally
> free system has now been converted into a non free one.


So therefore, B+A is not free, even though A is free and usable
independently of B. But since B+A contains A then A has been
made not free, even if A is distributed independently for free,
since a _version of A_ (namely that formed by A+B) is _not_
free anymore. And only _one_ unfree version even if A is still
freely available is a hindrance to the freedom (because *A+B*
as a _single entity_ *regardless* of how it is distributed is _not_
free). Is my understanding here correct?


> The GPL points out that A+B is a derivative of A. It says that A+B must
> have the same rights as A. So A+B needs to be GPLed.

> And that's what "to ensure that free code remains free" means.



Because A+B is intrinsically free. The "free code that remains
free" is A+B, not just A. A+B has an intrinsic, inseparable
attribute of freedom by definition.


> Now to appease Alfred, B's author can in fact release B under any
> license he/she sees fit. It's up to the author of A to call the
> copyright violation of the GPL out to the author of B and work something
> out. A judge can enjoin B's author from distrubuting the collective
> work, or B separately, though the judge cannot force B's author to GPL
> B. Is that enough legalese?


So then even if A+B is released under GPL, a pure B copy, that
perhaps included an original component to replace the functionality
that A provides, or just without said functionality, can still be
released under a different license.


> End the end what you want is too much of a slipperly slope. The only
> reason not to release B under the GPL is to keep downstream developers
> and users from having the same rights that B's author had to A. That
> diminishes the overall freeness of the system A+B.


Oh, of the _system_. So the _system_ A+B is free from it's creation,
and what GPL is "keeping free" is that system, since from creation it
was free.

---

So, are any of these right? Did I finally get the drift? Were my
understandings
finally corrrect at last?