Stallman Cranks Dat Soulja Boy!

http://youtube.com/watch?v=7C6r6fG4k40

>>121
Actually, the license includes a line that says something along the lines of "or any later version of the GPL," which is quite troublesome...

>>118
There is absolutely no problem for someone to USE a GPL program. The GPL3 covers the conveyance of the licensed work. The GPL3 covers the conveyance of works that are derived from the licensed work.

Think about what this means long and hard and think about what you have written. The following hypothetical is allowed:
1. Person X obtains a copy of Foobar which is licensed under GPL3
2. Person X modifies their copy of Foobar
3. Person X publishes a patchset of the modified code under the name Corge. Corge does not include any Foobar code AND is published under a GPL-incompatible license.
4. Person X conveys a copy of Bazqux (a work that resulted from combining both Corge and Foobar) to Person Y.
5. Person Y receives Bazqux as well as the associated code under GPL3.
6. Person Y receives a copy of Corge from Person X. Corge is still GPL-incompatible.

All of this is allowed, as Corge is a modification to Foobar but does not contain any of Foobar. The licensing terms of Corge does not have to be GPL nor does it have to be GPL compatible. Bazqux is GPL3 because it is a derivate of Foobar.

Please remember what you said:
GPL specifically considers all modified code to be under GPL

I am a paedophile.

SUPERMAN DAT HOE

p a e d o p h i l e

>>131
Why do I have an obsession with naked children?

>>125
http://img249.imageshack.us/my.php?image=ihbtjs2.png

>>133
The point is that there is a distinction between a modification that forms a derivative and a work that stands on its own. The modification can stand on its own without being subject to the original terms as long as it doesn't form a derivate with the original.

>>136
How can patches be considered unrelated?

>>137
Patches to a GPL code base distributed on their own are GPL violations.

The entire code base must be included when distributing a modification to a GPL work.

>>138
That isn't true. You can make plugins and shared libraries under the GPL, and they don't have to be distributed with the program. There are a large number of GPL libraries that aren't even tied to any specific program.

>>139
I'm talking about patches generated by diff(1).

DIFF(1)                          User Commands                         DIFF(1)

NAME
       diff - compare files line by line

>>136
Did you not get the point? A statement like "all mods to GPL code are GPL'd" is false. The fact that they are modifications does not mean the modifications are subject to the GPL. Only conveyed derivative works are subject to the GPL. Unconveyed derivative works are not subject to the GPL and yet, this situation is included in your "all mods" statement.  Corge, a modification for Foobar is not a derivative of Foobar and yet, this situation is included in your "all mods" statement.

>>141
"    A major goal of the GPL is to build up the Free World by making sure that improvement to a free program are themselves free. If you release an improved version of a GPL-covered program, you must release the improved source code under the GPL.

I want to distribute binaries, but distributing complete source is inconvenient. Is it ok if I give users the diffs from the “standard” version along with the binaries?

    This is a well-meaning request, but this method of providing the source doesn't really do the job.

    A user that wants the source a year from now may be unable to get the proper version from another site at that time. The standard distribution site may have a newer version, but the same diffs probably won't work with that version.

    So you need to provide complete sources, not just diffs, with the binaries.

Can I make binaries available on a network server, but send sources only to people who order them?"
http://www.gnu.org/licenses/gpl-faq.html#DistributingSourceIsInconvenient

>>142
Corge, a modification for Foobar is not a derivative of Foobar
I will only trust this when it has been proved in a court of the highest instance.

>>143
Distribute the patch WITHOUT the binary.

>>145
I don't think that applies, but I haven't been able to find anything saying one thing or the other.

I have, however, heard that it is indeed the case for that as well.

>>145
Ah, how about this!  To be GPL-compliant (a GPL-based patch is obviously under the GPL) is must include the whole license and a written offer (or the source code).

>>147
It depends on the case. A patch that includes a non-trivial quantity of GPL code must also be GPL IF it is to be distributed to third parties, after all, it is a non-trivial quantity. A patch can quite easily contain only the interfaces of the code functionality and have it's own expression of a particular solution or concept.

>>150
WRONG. If copying interfaces are considered derivative works, then Blackdown would not be possible without Sun's permission because it would be an infringement of the Java interfaces. Linux would not be possibble without Novell's permission because it would be an infringement of the Unix interfaces.

A patch that modifies an interface without including the originating code does not form a derivative.

>>151
Does that patch consist of anything on its own?  No, it does not.  It requires the source work, therefore it it a derivative work.

>>152,153
Is the ReactOS system a derivate of Microsoft's Windows system? If you say yes, Microsoft wants to make you their legal counsel in charge of shutting down the Wine and ReactOS projects.

A patch that implements it's own expression of an interface is not necessarily a derivative. A patch that includes a non-trivial amount derived code will make that patch a derivative.

I don't know what a patch is.

>>154
Is the ReactOS system a derivate of Microsoft's Windows system? If you say yes, Microsoft wants to make you their legal counsel in charge of shutting down the Wine and ReactOS projects.
No because ReactOS is not a patch to the Windows code base.

A patch that implements it's own expression of an interface is not necessarily a derivative. A patch that includes a non-trivial amount derived code will make that patch a derivative.
A patch is based off another work (unless it's just adding new files), therefore I would think in most cases that it is a derivative work.  Please provide a code example if you are going to keep talking about interfaces (what the fuck is that shit anyway).

>>156
Do you know why the audit was commissioned? It was because of allegations of copyright infringement. The audit has been completed and the ReactOS team claim that all is well with their codebase, that there is no danger of copyright infringement. So what are the ReactOS team doing now? They are implementing their own expressions of Microsoft API's (among other things). There isn't much that Microsoft can do about that as long as the ReactOS system doesn't form a derivative of the Microsoft system.

This was my point all along:
A patch that implements it's own expression of an interface is not necessarily a derivative. A patch that includes a non-trivial amount derived code will make that patch a derivative. You are telling me that all modifications to a GPL program automatically make the modifications to also be GPL. I am saying you are wrong.

>>158

//original function
results getTreasure(map room, char * treasureName, coord treasureLoc)
{
  checkRoom(room);
  //50 other statements go here
  if (returnItem (room, treasureLoc) == treasureName)
    return congratulations(treasureName);
  else
    failure();
}

//a different function but keeps the same interface
results getTreasure(map room, char * treasureName, coord treasureLoc)
{
   path Path;
   enterRoom (room);
   path = calculatePath (treasureLoc);
   if (path)
     moveChar(path);
     treasure = openTreasure();
     if (treasure.name == treasureName)
       return congratulations(treasureName);
   else
     return failure();
  
}
They both achieve the same goal but use a different means to achieve it. The interface to these functions (entry points and return points to the function) remain constant. The modified function implements it's own functions and does not call on any derived code. You can change the functionality of a program without deriving from the original.