The GNU General Public License, which is the most widely used free-software license and is used to license the open-source Linux kernel, is set for its first revision in 13 years. Linus Torvalds, the creator of the Linux operating system, last week weighed in on the upcoming challenges facing GPL Version 3.
Torvalds: GPL Needs Minor Work
About The Author
Eugenia Loli
Ex-programmer, ex-editor in chief at OSNews.com, now a visual artist/filmmaker.
Follow me on Twitter @EugeniaLoli
He made the kernel, not the OS… i wouldn’t normally say something about this, but you’re talking about something else Stallman-generated so I thought it was relevant…
and now I see it’s a quote from the article… bad eweek, bad…
All of these look to be resolved in GPL v3, but not to my satisfaction:
1) The Internet
The GPL doesn’t seem too terribly aware of the existence of the Internet. Simply put, if you redistribute binaries of GPL software through physical rather than networked means, the GPL requires that you honor requests through the source through physical means if it’s demanded of you. Attempting to honor them through networked means may satisfy the person making the demand, but by the text of the license they can hold you to physical delivery for only the cost of media. Apparently, by the text of the GPL, your time is inherently worthless. If you ship binaries of GPL software, and someone asks you to mail them a CD of the source and won’t take a URL for an answer, you’re required to mail them the source upon demand. Ouch.
Of course, RMS’s solution would be to always ship source with binaries, which, of course, cuts the space available on a given medium about in half, or worse…
2) Static vs. dynamic linking
Some people like to think they have the answer to this, but they don’t, and likely in court one could easily make a case for building a dynamically linked, closed source application using a number of GPL libraries. It all comes down to the definition of a derived work, and simply put if your closed source application is in no way derived from GPL code (think writing your own GPL-licensed wrappers for GPL code then using them in your closed source application) then it does not violate the literal wording of the GPL.
3) License revocation
Section 4 of the GPL is vague and confusing:
…parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance.
For example, the developers of nmap revoked the GPL after SCO made a case against the legality of the GPL. However, within the scope of nmap itself SCO was in full compliance of the GPL, and therefore according to section 4 the authors of nmap should not have the right to revoke the GPL.
… (think writing your own GPL-licensed wrappers for GPL code then using them in your closed source application) …
How would this help? If the “wrapper” is GPL too then you might as well just be linking directly to the original library. Anything that is dependent or dirived on GPL code must also me licensed as GPL and no executable code can be dependent on “non-free” code or else it cannot be licensed as GPL.
This is fairly clear.
1) Internet
“If you ship binaries of GPL software, and someone asks you to mail them a CD of the source and won’t take a URL for an answer, you’re required to mail them the source upon demand. Ouch. ”
Basically URL is a customary means of method of distribution as GPL demands so they WILL have to take URL as an answer..
)2) Static vs. dynamic linking
gpl relies on copyright here which has legal grey areas regarding this. attempting to redefine this will never be universally applicable. there is obsolutely no easy out here
“3) License revocation ”
anybody who doesnt comply with the gpl may face license revocation. nmap authors couldnt have legally revoked the license. basically they didnt have anything from sco other than loose statement NOT made on court so yes what they did was not applicable
Looking back at the historical postings surrounding the early days of Linux shows that the term Linux has been associated both with the kernel and with the OS that Linus put together and distributed. So, the statement that Linus is the creator of the Linux Operating System is accurate — it doesn’t mean he wrote all of it, but he is the one responsible for putting it all together and distributing the OS under the name “Linux”.
For instance, see this usenet post, in which Linus talks about both the Linux kernel and the Linux OS distribution:
http://groups.google.com/groups?selm=1992Jan9.121044.18825%40kl…
RMS’s stated desire to distinguish the OS from the kernel can be accomplished by using the terms “the Linux kernel” and “Linux” (the OS). Since these are the terms most widely used (especially in the media), this is probably the best way to go.
The whole point of GPL is to prevent proprietary forks from being created. you are just deriding pope for preaching christianity
“I think GPL needs to allow closed source.”
No Sir, I think you need to read up on GNU philosophy.
1) The Internet
By my reading of the GPL, the only obligation you have is to provide the source code when requested. There is no specific requirement of providing it on physical media. Indeed, if you look at section 3, it says:
3. You may copy and distribute the Program (or a work based on it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you also do one of the following:
a) Accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or,
b) Accompany it with a written offer, valid for at least three years, to give any third party, for a charge no more than your cost of physically performing source distribution, a complete machine-readable copy of the corresponding source code, to be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or,
c) Accompany it with the information you received as to the offer to distribute corresponding source code. (This alternative is allowed only for noncommercial distribution and only if you received the program in object code or executable form with such an offer, in accord with Subsection b above.)
So, basically, all you have to do is meet *one* of (a), (b) or (c) above, not all.
2) Static vs. dynamic linking
Personally I think the GPL is very clear on this point – the FAQ even addresses it directly. If you link to GPLed code, the resultant binary is “derivative” and must also be GPLed.
It all comes down to the definition of a derived work, […]
Actually I think you’ll find the relevant definition of “derived code” is the one within the GPL
.
[…] and simply put if your closed source application is in no way derived from GPL code (think writing your own GPL-licensed wrappers for GPL code then using them in your closed source application) then it does not violate the literal wording of the GPL.
The intention of the GPL is clearly that linked code – dynamic or static – be considered a derivative work. Therefore, it would be reasonable to conclude, anyone who licenses their code under the GPL also implicitly agrees with this intention.
For example, the developers of nmap revoked the GPL after SCO made a case against the legality of the GPL. However, within the scope of nmap itself SCO was in full compliance of the GPL, and therefore according to section 4 the authors of nmap should not have the right to revoke the GPL.
I think you’ll find the allowance for license revocation is targeted at code already released and available under the GPL, not a new release. Ie: retroactive code relicensing.
I didn’t follow the nmap re-licensing events closely, but I assume that they only changed the license on *new* releases of nmap, not existing releases. Assuming all the copyright holders of code found in nmap agreed on this step, by my understanding their actions would be perfectly ok (childish and petulant, but still following the conditions of the GPL).
If they attempted to revoke the GPL on already released versions of nmap – assuming SCO really was following the terms of the GPL properly (and I believe they were) – then I agree, they haven’t got a leg to stand on.
What happens to all the old code licensed under the old license.
eg. Recently we had CherryOS and that persons other projects.
We also had that other company using mplayer code.
Will these companies be able to find loopholes in this older GPL license.
”
eg. Recently we had CherryOS and that persons other projects.
We also had that other company using mplayer code”
both of these are already illegal. there is no new license required to cover up any holes in these particular cases
…in court one could easily make a case for building a dynamically linked, closed source application using a number of GPL libraries.
I don’t think anyone in their rigth mind would risk this. The company I work for are quite liberal when it comes to using open source components in our software (huge, complicated, expensive, distributed systems…), but there is one exception: GPL’ed code is absolutely verboten! Static or dynamic linking; it makes no difference. We’re actually using mysql (GPL) for some non-critical stuff, but even if the only contact between our code and mysql is through the network, we’ve bought a comercial license for it. Just can’t risk it. Our customers and partners probably wouldn’t accept it either.
“but there is one exception: GPL’ed code is absolutely verboten”
as long as you dont link to gpled code you are free to use it along with proprietary code. no need to run away scared. there is a lot of good stuff with gpled code you can use freely
That is a little extreme but that is also the safe way to go.
You can use GPL software without probelms. It’s only when you modifiy it AND distribute that software. If your keeping it in-house a note saying that this software can’t leave the company.
GPL software only affects you when you DISTRIBUTE the software.
“I think GPL needs to allow closed source.”
The GPL does allow closed source code. There are a few fundamental restrictions though…
1.) If you want Closed Source and distribute it, you will have to use code not licensed under the GPL. So Closed Source is allowed outside of the GPL.
2.) If you mix and match various code and some of it is GPL, you are barred from distributing this code under anything else than the GPL. If this is not an option, you have to keep this in house and not distribute it. Thus it is not publicly available and can be considered closed source.
See, the GPL license allows Closed Source. It might not be in the way most people want, but technically the GPL does not bar Closed Source.
How would this help? If the “wrapper” is GPL too then you might as well just be linking directly to the original library.
Except it can now be argued that the closed source program is using an interface of your own design and is therefore no longer a derived work of the GPL code. Since the GPL revolves around the concept of derived works and places no restrictions on static versus dynamic linking, a program dynamically linked with GPL code which cannot be demonstrated to be a derivative of the GPL program no longer violates the language of the license agreement.
Certainly it’s in violation of the spirit of the GPL, and that’s why the static/dynamic linking issue needs to be clarified.
If you wish to argue this further, please make explicit references to the text of the license agreement, not your layman’s interpretation thereof.
“If you wish to argue this further, please make explicit references to the text of the license agreement, not your layman’s interpretation thereof.
”
please do what you advise others
The GPL grants permission to redistribute someone else’s copyrighted material if you do two things:
1) Accept the license
2) Follow the terms of the license
Most GPL violations concern the second part. A typical example is distributing GPL software in binary form without making the source available, as the GPL requires. Without the permission granted by the GPL, distribution of the binary is infringement of copyright. It only applies to the specific material that was distributed without following the license terms, and not to any other software using the GPL.
SCO has done something unusual, in that they stated under oath that the GPL is invalid. I can only interpret that as meaning that they refuse to accept the GPL. That’s a blanket refusal covering ALL software under the GPL, not a violation of the distribution terms for a specific piece of software.
SCO appears to have followed the terms of the GPL other than accepting the license. The author of nmap did not revoke the GPL license for his property, he put SCO on notice that they themselves had revoked their acceptance of the GPL, and therefore lacked permission to distribute his code. He doesn’t feel that following the terms of the GPL is good enough, that SCO must actually agree to accept the license before the terms apply. I think he’s right. I can’t simply take money from my bank and send them a payment every month, I must actually agree to a mortage contract before they will loan me the money. The fact that I meet the conditions and follow the terms of a mortgage contract means nothing if I refuse to accept the contract.
SCO’s distribution of nmap under the conditions given by the GPL implied acceptance of the GPL. They have revoked that acceptance, and therefore the permission to distribute nmap is automatically revoked. The copyright holder has put SCO on notice that they do not have permission to distribute his work. He did not revoke the GPL; nmap remains under the GPL, SCO remains in violation of the GPL, and SCO does not have permission to distribute nmap.
Once the GPL is rejected or violated, restoration of the license agreement is not automatic. The copyright holder often restores the agreement when a violator comes into compliance, but that’s up to the copyright holder, not the party who broke the agreement. SCO has been informed of that. SCO unilateraly withdrew from the license agreement, and any future agreement requires a specific offer from the copyright holder. SCO can’t restore GPL distribution rights on its own.
The license for nmap has not changed. SCO rejected that license. Those are the only facts that matter; all of the rest is just noise. The copyright holder released nmap under the GPL, and he can’t revoke that license. He can refuse to restore agreement to those who reject or violate it, and many have confused that refusal with revocation.
Imagine there is a (dynamic) library abc.
There are two compatible implementations: one commercial, and one GPL, the latter is the one everyone uses.
Any company can link against the commercial library, but the code will run on both.
Who is in violation of GPL here? Is anyone in violation?
That’s a hole of the GPL.
“Who is in violation of GPL here? Is anyone in violation? ”
did you even bother to check the GPL FAQ?. NO?
besides GPL’ed software is sold commercially too so your whole argument is bogus. maybe there is a hole elsewhere in you
Interface your closed code to a BSD interface that links to GPL code?
” BSD interface that links to GPL code?”
bsd interface is considered gpl derivative which in turn would affect your *proprietary code*. no problem if its just commercial
Just curious here.
Let’s say, for instance, I took the whole Linux kernel and started distributing it as the basis for a proprietary OS. That’s a clear GPL violation, but who actually holds enough copyright on the original source to impose it?
If I can get a few contributors to refuse to apply their copyright, or even purchase assumption of their copyright entitlements, then can the others legally sue over license violation for only their contributions?
That’s not flamebait, I am actually thinking of how the GPL applies to projects with multiple contributors. GPL as a license might be applicable to the project as a whole, but copyright on individual contributions rests with the originator of that contribution (AFAIK). Without appropriate copyright the license is invalid.
I expect OSnews to differentiate between a kernel and an operating system.
Interface your closed code to a BSD interface that links to GPL code?
Still won’t work. The BSD code would become GPL code and hence the closed code would then be interfacing with GPLed code.
-nt-
I do hope that the new GPL does address web based applications. I have seen a few content management systems have requirements on displaying copyright info on a hompage or login page. I have no problem doing this but I don’t understand why it is not alright. I also think that just because a person installs a web application that doesn’t mean the person has distibuted it and is required to even offer license info. For example, osCommerce hosting.
Just my two cents…
The current GPL uses copyright law, and for the most part, copyright only addresses distribution, not use. But copyright does restrict public performance without permission of the holder. I wonder if the use of copyrighted software in a web page accessable to the public could be considered a ‘public performance’ covered by copyright?
It would be novel, but then again, it wasn’t that long ago that the idea that copyright applied to software was novel.
Still won’t work. The BSD code would become GPL code and hence the closed code would then be interfacing with GPLed code.
Then the GPL is the borg :b
What about using an Apple opensource license or Sun or…
Does everything become GPL?
When Abiword runs on top of Windows does that make Windows GPL? Hand over the code MS!!!
If your reply is “no no it is interface with OS binaries” Then it is okay.
What if I create a BSD licensed code, then compile it, and then my program runs as follows.
Close proprietary -> BSD licensed -> GPL
Then the GPL is the borg :b
That’s one way of putting it. It’s the “viral” aspect everyone goes on about.
What about using an Apple opensource license or Sun or…
Does everything become GPL?
Depends on the exact license. BSDL is about as close to completely free as you can get without being public domain, so the additional restrictions imposed by the GPL are “compatible” with it (ie: they don’t contradict any of the BSDL’s restrictions). The “OSS” licenses used by Apple, et al probably don’t allow that sort of thing because they’re more restrictive again than the GPL.
When Abiword runs on top of Windows does that make Windows GPL?
No.
What if I create a BSD licensed code, then compile it, and then my program runs as follows.
Close proprietary -> BSD licensed -> GPL
Depends how they communicate. According to the FSF (IIRC), if your BSDL code shares memory space with the GPLed code then it should be considered “derivative” code (the likewise for the closed code), but if it just passes stuff through named pipes it should be ok.
To use the language of GPLv2, a URL is not “a medium customarily used for software interchange” because a URL is not a medium at all and having a URL for something will not substitute for having a copy of that program’s complete corresponding source code. A URL is merely a pointer to a resource.
One of the major problems with URLs is that URLs don’t last. Despite the intention of the site maintainer and the ability for website servers to redirect URLs, many URLs become obsolete because they no longer point to what they used to point to. Imagine what will happen if URLs generally become obsolete because we’ve moved on to some other means of pointing to resources. This is covered quite well in the GPL FAQ http://www.gnu.org/licenses/gpl-faq.html which I recommend reading in its entirety. I also recommend taking the GPL quiz.
This attempt at modernizing the GPL to make it aware of the Internet is doomed to fail. A similar problem plagues the Creative Commons licenses–with no plain text copy of the licenses available from CreativeCommons.org, people often point to the online copies. But this means there is a single point of failure; if the CreativeCommons.org website goes down, someone could not know what their rights are with the work. Better to include a copy of the relevant license text, even if it means embedding a long string in a movie file or compressed audio file. This way, the rights and responsibilities one has with the work will travel with the work. For computer software, this has not been a problem because plain text copies of licenses are readily available and are commonly packaged with the software.
None of the points you’ve raised are the most significant points to be clarified or strengthened in GPLv3. Addressing software patents license grants more clearly, incorporating anti-DMCA language, and specifying responsibilities for web services (or the like) are much more likely to be addressed in GPLv3.
Finally, despite this being an “open source news web site” (quoting the “rules” page from OSnews), the GPL is properly addressed as a free software license. RMS and Eben Moglen are the two authors of the upcoming GPLv3 and both make it clear in their talks and essays that the work they do, they do for the free software movement. The fact that the GPL is listed as an open source license is really not anywhere near as noteworthy as writing the license or building the community around the license, as was done roughly a decade before the open source movement began. I hope you will all choose to give credit where credit is due and call the GPL for what it is, regardless of your impressions of the FSF or the free software movement. The GPL is also listed amongst the licenses approved of by the Creative Commons organization, but nobody would call the GPL a Creative Commons license. Everyone knows that the people at CC didn’t write the license and nobody has any desire to confuse the authorship of the license with the work done by the CC organization. The same is true of the Open Source Initiative; they didn’t write it (the GPLv3 will be the first version of the GPL to be written since the open source movement began), and we should not credit them with another’s work.
That’s one way of putting it. It’s the “viral” aspect everyone goes on about.
The GPL is NOT in any way, shape, or form “viral”. To be viral it would need to have the power to convert code into GPLed code without the consent of the code’s copyright holder. The GPL does not have the power of a contract–it is just a license which grants extra rights above and beyond copyright law to those that follow its restrictions. See this article for a more in-depth discussion on this point:
http://www.groklaw.net/article.php?story=20031214210634851
The sole extent of the GPL’s powers is to take away its grant of extra rights if you do not follow its restrictions, thus making any redistribution that does not follow the GPL a violation of copyright law.
Yes, BSD code can be released under a GPL license (which would make it dual licensed) because of the permissivness of the BSD license, but the code doesn’t magically turn into GPLed code just by being near GPLed code–a human must choose to make a release of some BSD code under the GPL for that to happen.
playing devils advocate:
hmm if i write a wrapper class arrround gpl code, this must be gpl! and if i link to this wrapper class this must be gpl too!
EXCEPT i have written the wrapper class, didnt i ??
so i would only violate my own copyright ??
so, assuming i wont go to court against myself, why shouldnt i release my product as closed than ?? who is there to sue me ??
(there must be a point i dont see, please enlighten me
EXCEPT i have written the wrapper class, didnt i ??
so i would only violate my own copyright ??
If you link to GPL code, the wrapper must be GPL.
If you use the wrapper (that have now become GPL), the program must also be GPL
It doesn’t matter how far out you go, each step beyond GPL must also be GPL.
It’s quite easy
You wrote the wrapper around GPL code. I you distribute this wrapper with the GPL’d program you must agree to the terms of the GPL and therefore the wrapper code is GPL’d
If you don’t agree and distribute the original GPL’d program with your wrapper the authour of the origianl GPL’d code has every right to revoke the licence you have to distribute their code.
If you distribute the wrapper on its own, say its a dll wrapper around a GPL’d DLL then it depends on how you wrote it.
If you used header files from the original GPL’d programs source code, you are still in violation as you used copyrighted source (the header) in a contrary manner to the licence (the GPL) you had to distribute binaries derived from use that source.
i would of course distribute the wrapper as gpl code, but what about my code, that relies on the wrapper ??
gpl or not, i own the the copyright to the wrapper class, and i wont sue myself …
I think there is a lot of confusion about what NMAP did. Answering a few questions will help us understand what they did.
1. Does SCO have any right to re-distribute NMAP code except as governed by the GPL?
2. Does re-distributing code under the GPL require you to accept the GPL as valid?
3. Does SCO accept the GPL as valid?
4. If SCO does not accept the GPL as valid, under what license are they distributing NMAP?
5. Go back and answer question 1.
I don’t see anything wrong with what the NMAP guys did. SCO has mentioned under oath in court that the GPL is invalid and violates the constitution of the USofA. The NMAP guys called SCO to their bluff.
All that SCO has to do is acknowledge the GPL as a valid license and be in compliance. IBM has used the same tactic to corner SCO in court. Why do you think they are so silent all of a sudden?
The BSD code would become GPL
No, BSD code is still BSD code. It does not become GPL magically, neither it changes its licence. When someone makes a derivative work of a GPL code, he has to redistribute it publically as GPL. But he may redistribute his code in BSD or any GPL-compatible licence. BTW, there is some BSD code in the Linux kernel too.
The story of GPL being “viral” is false and pure FUD, and sadly a lot of people make this error. Actually, you can include any GPL-compatible code in GPL code and reuse it separately for other projects under the terms of the original license.
See http://www.gnu.org/licenses/license-list.html#GPLCompatibleLicenses
To use the language of GPLv2, a URL is not “a medium customarily used for software interchange” because a URL is not a medium at all and having a URL for something will not substitute for having a copy of that program’s complete corresponding source code. A URL is merely a pointer to a resource.
This is semantics. It’s a bit like arguing a person’s address isn’t “a medium customarily used for software interchange” and therefore giving that information with your binaries so the users can contact you for the sourcecode doesn’t meet the requirements.
A URL is a pointer to a website. A website (these days, at least) is most certainly “a medium customarily used for software interchange”.
One of the major problems with URLs is that URLs don’t last. Despite the intention of the site maintainer and the ability for website servers to redirect URLs, many URLs become obsolete because they no longer point to what they used to point to.
People move house as well. Business go bust. Etc.
I see no way that distributing source via the internet (FTP, WWW, whatever) doesn’t meet the requirements of the GPL.
i would of course distribute the wrapper as gpl code, but what about my code, that relies on the wrapper ??
Since it (presumably) links with the wrapper code, it must also be GPLed. And so on.
This is precisely why the LGPL was crafted.
Re: Just curious here.
Let’s say, for instance, I took the whole Linux kernel and started distributing it as the basis for a proprietary OS. That’s a clear GPL violation, but who actually holds enough copyright on the original source to impose it?
If I can get a few contributors to refuse to apply their copyright, or even purchase assumption of their copyright entitlements, then can the others legally sue over license violation for only their contributions?
That’s not flamebait, I am actually thinking of how the GPL applies to projects with multiple contributors. GPL as a license might be applicable to the project as a whole, but copyright on individual contributions rests with the originator of that contribution (AFAIK). Without appropriate copyright the license is invalid.
Let’s pretend the kernel has 200,000 files (this number is wrong, please don’t correct me, just making an example). If I own the copyrights to 30 of these files, and I want to release the kernel for use in a proprietary OS, I can only put my 30 files in the OS, not the whole kernel. If I put the whole kernel in, I would not only be violating Linus’ copyright on the whole collected work, but also every other contributors copyright. Does that answer your question?
If what you said was true, then Linus could legally freely redistribute Red Hat Enterprise Linux (the entire collected work) just because he owns the copyrights to part of it.
You should go to http://www.fsf.org and actually read the GPL…it should answer most of your questions.
No, BSD code is still BSD code.
Actually, as someone else has pointed out, strictly the code would now be dual licensed. On its own, it would be available under the BSDL, but used in conjunction with the GPLed code, it would be GPLed.
It does not become GPL magically, neither it changes its licence. When someone makes a derivative work of a GPL code, he has to redistribute it publically as GPL. But he may redistribute his code in BSD or any GPL-compatible licence.
Only if he distributes that code *separately* to the GPLed code. Distributed together (as binaries) both must be GPLed.
So, apparently people aren’t really trying to follow your example…
Given that a) code dependent on your wrapper would be based on the wrapper based on [insert original gpl code here], it would have to be GPL, and B) You own that copyrights for said wrapper…
A –> B –> C
I think, legally, nobody could say anything about it, as long as your code called a wrapper function and not an [insert original gpl code here] function
A –> Bsub12
but not
A –> Csub4
This way you could claim independence of the original GPL code, as you could substitute the wrapper for something using other code that was non-GPL
A –> B –> D
A would be totally independent of C or D in this case…
People could complain, but I think you’re right in assuming that in that case the author of [insert original gpl code here] would have no say on code A.
To quote fsf.org:
Who has the power to enforce the GPL?
Since the GPL is a copyright license, the copyright holders of the software are the ones who have the power to enforce the GPL. If you see a violation of the GPL, you should inform the developers of the GPL-covered software involved.
So, yeah, legally you should be in the clear, since you would only be violating your own license…
I think, legally, nobody could say anything about it, as long as your code called a wrapper function and not an [insert original gpl code here] function
A –> Bsub12
B must now be GPLed.
This way you could claim independence of the original GPL code, as you could substitute the wrapper for something using other code that was non-GPL
True, he could claim independence of “the original GPL code”. Unfortunately, his closed source app (presumably C) is a derivative of code that is GPLed, and hence must be GPLed as well.
So, yeah, legally you should be in the clear, since you would only be violating your own license…
No.
If we assume:
A = GPL code
B = wrapper code
C = closed code
The interface goes:
A – B – C
Firstly, for B to _legally_ be able to link to A _at all_, it must be either GPLed, or released under some “freer” license. Thereafter, the derivative code (A – B) is GPLed.
Now, for C to _legally_ be able to link to B, it must also be GPLed, or released under some “freer” license. Thereafter, the derivative code (B – C) must be GPLed.
If C is _not_ GPLed, then it cannot legally link to B, which is GPLed. If B is not GPLed, then it cannot link to A. This is completely independent of copyright as it is a condition required by the software license.
This “license cascade” is the whole goddamn reason the GPL exists. The whole *point* of the GPL is to produce more GPLed code by requiring basically any code that “interfaces” with it to also be GPL.
This is the thing so few people seem to understand – the point of the GPL is not to keep code fragment A “free”, it’s to “force” any other code that wants to use code fragment A to become GPLed as well. In short, the GPL isn’t about *your* code, it’s about *their* code.
You don’t read things very well…
Firstly, C is the original code… which is why A can be pulled away from C to D…
Seriously, work on reading comprehension a little there pal… Now stay with me here, I’ll see if I can put this in a way that you can comprehend.
C has no bearing on A, because the only thing that the GPL says is that the author of B must enforge A to use GPL, following that A is GPL because B is GPL… so, if A does not release code, GPL says author of B (also author of A) is the only one who can do a damned thing about it… hence he is in the clear…
That’s why I pointed out the little blurb from fsf.org..
YOU need to read the rest of the argument before going off on some rant about something completely unrelated to what the person said…
Yes, because C is GPL, B has to be GPL, and because B is GPL A has to be GPL, but, because A was written by author of B, if A is not GPL, legally, there is not a damned thing anyone can do about it…
that was my whole point…
jerk
*enforce
Bleh, sorry, that was a bit testy, it’s just annoying when people argue something without addressing what I said…
So here it is, clear, and not derogitory towards anybody…
the GPL is provided so that all code connected to GPL code must also be GPL in order to be allowed to use the code.
So, if
C = original GPL code
B = wrapper
A = new program
(I use C as original for previous replacement example)
Then the wrapper must be GPL and so must the original program
However
Because the GPL is only meant to protect copyright, as long as A does not contain or link to any part of C, the author of the original code can only legally say that B must be GPL.
The GPL states that A is also GPL, but it is up to the author of B to enforce this.
Because A calls fuctions from B and not C, B can be rewritten to use D without changing A at all, which seperates A from the rights of the author of C, so C would have no legal rights over A.
Hence, the author of A would at that point be working with his own copyright, and as such nobody could say anything if he broke it.
All this assumes a distance between A and C, so they are indeed seperated. Yes, according to the GPL license A would still have to be GPL, but because A only uses B code, only B can complain. Done correctly it would be the same as a dynamic library. I did not say A does not have to be GPL, I said if A breaks GPL nobody has a legal right to do anything about it.
Things are a lot different than they were 13yrs ago. Especially in the computing field. Take Linux, it was just a project now its a major player. If open source software is to survive corporate interest then the GPL needs to stay on top of the game.
Its a good CYA method for Opensource users. We’re probably going to see more frivolous law suits as Linux starts to gain momentum and companies like Microsoft who have an interest in derailing Linux look for ways to discredit the OS.
-Nx
Thanks Mishell, i think you got my point.
Now this left me thinking:
1. If this is the way things are, where is the border:
what about a really simple wrapper like
float mywrapper_FN(int x, string y)
{
return gpl_FN(x,y);
}
these could even be automatically constructed
2. Does this even matter ??
Maybe the point of the GPL isnt to infect every other programm of the planet?
Maybe the GPL is NOT
“provided so that all code connected to GPL code must also be GPL in order to be allowed to use the code.”?
Maybe it isnt even possible to make a license that would enforce such?
OK, step by step now:
first:
My Opinion wasis that the point of the GPL is to protect existing projects. that is if i release source-code i want to make sure that my code stays GPL. But the GPL should not be (imho) intented to force any license to any other project.
– free software is about freedom, freedom to choose a license is a freedom to , isnt it
ok second:
is a truly viral license possible ??
ill list two points that made me thinking.
– are interfaces(like headerfiles) copyrightable ?? (i think they are not ?!?)
– isnt copyright (and especially the GPL) about distributing (and maybe copying)??
– when i link dynamically to some library, than this is happening at runtime (and therefore usetime) , isnt it ??
where is the GPL catching in here (in my opinion it isnt)
thats what im wondering about at the moment
(but keep in mind im not a lawyer
When someone makes a derivative work of a GPL code, he has to redistribute it publically as GPL. But he may redistribute his code in BSD or any GPL-compatible licence.
GPL-“compatibility” works one way. BSD/etc.-licensed code can be distributed under the GPL license. GPL-licensed code (and derivatives) can only be distributed under the GPL license (unless the code was dual-licensed to start with, obviously). That’s why the GPL is viral — things come coming into contact with it GPL-free leave irreversibly GPL-laden.
That’s why the GPL is viral
No, it is not. A viral agent, like flu, you don’t chose to get it. This is not the case if you decide to do a derivative project from a GPL. You chose to put your code in a GPL project, nobody forces you. But you may write a piece of code in BSD licence and insert it in a GPL project. You may redistribute it under the GPL too.
And no, a BSD code in a GPL code does not become dual licensed. A piece of BSD code in a GPL project is still BSD and can be used under the BSD license elsewhere. Of course you have to remove any GPL insert from this code to be able to use it under the BSD license. However, the GPL code in a whole project can be redistributed only under the terms of the GPL.
“My Opinion wasis that the point of the GPL is to protect existing projects. that is if i release source-code i want to make sure that my code stays GPL. But the GPL should not be (imho) intented to force any license to any other project.
”
look. it doesnt force anything to be be gpl’ed. any aggregate product is considered a derivative. it wont somehow magically relicense your software.
” That’s why the GPL is viral — things come coming into contact with it GPL-free leave irreversibly GPL-laden.
”
oh please. under how copyright works and read the gpl license and faq. all your blithering and virus infected licenses are pure crap.
GPL-“compatibility” works one way. BSD/etc.-licensed code can be distributed under the GPL license. GPL-licensed code (and derivatives) can only be distributed under the GPL license (unless the code was dual-licensed to start with, obviously).
True, but its license does not change. If the piece of code is used as is in a file, inside a GPL project, its license is still BSD and can be used by third parties under the BSD terms.
That’s why the GPL is viral — things come coming into contact with it GPL-free leave irreversibly GPL-laden.
That’s false. If GPL code is inserted in several places of the BSD code, of course it makes it difficult to clean to be pure BSD. And yes you may redistribute a BSD code under the terms of GPL, but you cannot force a third party to not use it under the BSD terms if he has removed your GPL parts.
If I wrap a GPL library and release the wrapper under the GPL license then I’ve fulfilled all requirements of the GPL. At that point there is nothing to prevent me releasing a proprietary product that uses the wrapper to access the library because the only person who can enforce the license of the wrapper is me.
The original library creator can’t enforce the GPL on my proprietary code, only on the wrapper. Which means that as long as I’m careful not to violate any element of the license in my wrapper code, and don’t want to sue myself, then my proprietary code can ignore the original library license. The copyright holder of the original library only has the right to license use of the library code not subsequent use of the wrapper.
:If I wrap a GPL library and release the wrapper under the GPL license then I’ve fulfilled all requirements of the GPL. At that point there is nothing to prevent me releasing a proprietary product that uses the wrapper to access the library because the only person who can enforce the license of the wrapper is me. :
the wrapper itself is gpled and is considered a derivative of the original code you create a wrapper for. so the original developer can challenge your proprietary code that is dependant on the wrapper you create. more questions to licensing AT gnu.org
A GNU public licence is a type of contract. A contract is only valid when both parties receive a consideration: i.e. customer receives goods from retailer in return for payment.
By giving copies of their program away without receiving anything in return, there is no contract established.
It should be possible to allow licencing using the GPL by way of a deed, where the author writes up the conditions any user must fulfil, then signs it in the presence of two witnesses. This may be revocable, if specified in the deed.
The GPL’s legal weakness is also the way that it may be possible for break-seal terms in a commercial program to be unlawful – unless the customer knew the terms when they bought the program, the terms are not integrated within the contract of sale.
“the wrapper itself is gpled and is considered a derivative of the original code you create a wrapper for. so the original developer can challenge your proprietary code that is dependant on the wrapper you create. more questions to licensing AT gnu.org”
na he cant, if i dont use his sourcecode directly …
(i could challenge myself, but i wouldnt
consider the simple fact that the wrapper is for more than one module (one gpl , one ive written myself, one … you get it ??).
the gpl isnt viral and it only works if i use your code directly, and distribute your code and my code together.
“A GNU public licence is a type of contract. A contract is only valid when both parties receive a consideration: i.e. customer receives goods from retailer in return for payment.
”
no it isnt. a gpl license is a *license*. not a contract. get your legal facts straight
“na he cant, if i dont use his sourcecode directly … ”
he can. go ask licensing AT gnu.org.
In your example, will A (new program) function without the presence of the original GPL code C? No, because B is simply a wrapper. A will still incorporate the code from C, so it will most likely be defined as a derivative work, and therefore the original author will be able to take action.
Admittedly this whole subject is less than clearly defined in legal terms, but the general consensus is that a ‘work’ is a derivative of another ‘work’ if it incorporates at least a portion of the original work in some form. The exact nature of that form is where the legal discussion continues, for example there is still debate over whether dynamic linking (even direct dynamic linking without wrappers) will produce a derived work.
Your wrapper scenario is not a way of bypassing the GPL though, which is probably why people don’t try it.
@Paul – GPL isn’t a contract it’s a licence, so contract law simply doesn’t apply.
flimflamman – don’t believe a word of it
using interfaces is imho not the same as beeing derived from something.
( xemacs is derived from emacs, my small el-script probably isnt … )
the same thing with dynamic linking (which we talk about, if i compile one large binary then i of course see why it is derived from the gpl-ed work)
maybe the same thing with using interfaces (ie headers) though im not sure about it (if, then we wouldnt need the wrapper class)
I’m not sure the derivative idea (And it’s just an idea until tested in court) can actually cascade like that.
In the example C has been clearly separated from A via the wrapper B and B fulfils all requirements of the the license agreement for A (Source available, free distribution etc). B definitely counts as a derivative, because it directly accesses the functionality of A. Likewise C is a derivative of B, but as copyright holder of B I’m choosing not to enforce B’s GPL with regards to C. Can derivative work status really cascade from A onto C? The FSF would certainly like us to think so, but I’m not so sure.
Since C isn’t actually accessing code in A, only code in B I don’t see any way for the owner of A to enforce the license on C. About all they could do would be to refuse to issue me with licenses for further versions of A or sue me if I violate the GPL in B. If A is able to count C as a derivative then effectively my copyright on B has been made subordinate to the copyright holder of A and there is nothing in the GPL that states that is what is will happen if I agree to the license.
In the end I think a court will probably have to decide the issue. However this is something that is pretty GPL specific. A proprietary license wouldn’t let me create B in the first place, and with a BSD style license I wouldn’t need B to provide separation.
The use of interfaces by itself doesn’t result in a derivative work, in the current legal situation the key is linking. As an example, you can write software using the Linux kernel interfaces and release it under a closed licence. You can do this despite the kernel being covered by the GPL because you’re not linking, that’s not how the kernel works. Going deeper and making direct function calls into the kernel, as in a kernel module, might be different but Linus currently allows this.
In the A -> B -> C example we’ve been discussing though. the code is being linked. Using a wrapper in this way doesn’t mean that the original library is no longer linked, so your new piece of software will still incorporate the original code. As things stand this would be seen legally as a derivative work. Now, all this could be changed by a court decision or two, but I sure wouldn’t want any of my money resting on a change.
As for subordination of copyright, your copyright on B hasn’t been affected in any way. Your licensing freedom has been restricted, but that’s a natural consequence of producing a derivative work, and you knew you were doing that from the start (nobody has claimed B isn’t derivative).
flimflamman – don’t believe a word of it
“Going deeper and making direct function calls into the kernel, as in a kernel module, might be different but Linus currently allows this.
”
NO. Linus has granted no exceptions. what he has personally clarified is that he doesnt intend to sue such people and considers it legitimate as long as they dont derive code . but he is not the significant copyright holder and has obsolutely no control over some other kernel developer deciding to sue the guys developing such modules.
“…with no plain text copy of the licenses available from CreativeCommons.org…”
The Creative Commons blurb recommended for use on CC-licenced websites reads: “To view a copy of this license, visit http://creativecommons.org/licenses/by-nd/1.0/ or send a letter to Creative Commons, 559 Nathan Abbott Way, Stanford, California 94305, USA.” So, a plain text copy of the licence can be obtained by mail. The system is not dependent on the stability of URLs.
Using a wrapper in this way doesn’t mean that the original library is no longer linked, so your new piece of software will still incorporate the original code.
That all depends on how I wrap this theoretical library. If I wrap it using function calls that get imported into my proprietary software then there’s a problem. But if I wrap it in such a way that B is standalone and communicates with C in a client/server fashion (Eg via shared memory/pipes) then A’s code is never linked to my code in C. Hence the license can’t cascade and C isn’t a derivative work of A despite using all of its functionality via B.
The reason I’m thinking this way is that the net is effectively one long pipe. No linking ever takes place, there are seperate applications passing information, but there’s no way (IMHO) information passing can result in derived work status.
Thanks Mishell, i think you got my point.
Everyone gets your point. The point you don’t get is that it is incorrect.
Maybe the point of the GPL isnt to infect every other programm of the planet?
Maybe the GPL is NOT
“provided so that all code connected to GPL code must also be GPL in order to be allowed to use the code.”?
Spending about five minutes reading about RMS and his philosophies should confirm that it is.
My Opinion wasis that the point of the GPL is to protect existing projects. that is if i release source-code i want to make sure that my code stays GPL. But the GPL should not be (imho) intented to force any license to any other project.
It’s not. Its intent is to require anyone who wants to use GPL code to also GPL their code.
– free software is about freedom, freedom to choose a license is a freedom to , isnt it
Depends who you ask.
– are interfaces(like headerfiles) copyrightable ?? (i think they are not ?!?)
What do you mean by “interfaces” ?
– isnt copyright (and especially the GPL) about distributing (and maybe copying)??
Firstly, copyright and the GPL are separate and distinct things.
Secondly, copyright is ostensibly about protecting the rights of “creators” to control the duplication and distribution of their work.
– when i link dynamically to some library, than this is happening at runtime (and therefore usetime) , isnt it ??
where is the GPL catching in here (in my opinion it isnt)
When the two bits of binary code link at runtime, then *at that time* they are considered derivative works.
This is actually the path that leads to the argument about why dynamic linking should not require the two parts to be GPLed – because the GPL doesn’t really have any teeth until the derivate code is distributed, and the two bits of code are only linked at runtime, *not* during distribution.
So, if
C = original GPL code
B = wrapper
A = new program
(I use C as original for previous replacement example)
Then the wrapper must be GPL and so must the original program
And hence, so must A.
Because the GPL is only meant to protect copyright, as long as A does not contain or link to any part of C, the author of the original code can only legally say that B must be GPL.
No. The GPL is *not* meant to “protect copyright”. That’s what the courts are for.
The GPL is meant to give developers certain rights (and responsibilities) *over and above* those implied or enforced by copyright law.
The GPL states that A is also GPL, but it is up to the author of B to enforce this.
No, it does not. The GPL states that for B to use C, B must be GPLed and for A to use B, A must be GPLed.
Remember, once you distribute A and B, anyone you distribute it to can then turn around and redistribute them at their discretion.
Hence, the author of A would at that point be working with his own copyright, and as such nobody could say anything if he broke it.
Please stop working under the assumption that GPL == copyright. It is incorrect.
If I wrap a GPL library and release the wrapper under the GPL license then I’ve fulfilled all requirements of the GPL. At that point there is nothing to prevent me releasing a proprietary product that uses the wrapper to access the library because the only person who can enforce the license of the wrapper is me.
Yes there is – to use the wrapper, your proprietry product must also be GPLed.
The original library creator can’t enforce the GPL on my proprietary code, only on the wrapper.
True. The point being that to use the wrapper, your proprietry code must be GPLed. If the proprietry code isn’t GPLed, then either it can’t use the wrapper, or the wrapper can’t be GPLed. If the wrapper isn’t GPLed, then it can’t use the GPLed code.
Again, this is the sort of scenario the GPL was specifically designed for.
“A GNU public licence is a type of contract. A contract is only valid when both parties receive a consideration: i.e. customer receives goods from retailer in return for payment.
By giving copies of their program away without receiving anything in return, there is no contract established.
It should be possible to allow licencing using the GPL by way of a deed, where the author writes up the conditions any user must fulfil, then signs it in the presence of two witnesses. This may be revocable, if specified in the deed.
The GPL’s legal weakness is also the way that it may be possible for break-seal terms in a commercial program to be unlawful – unless the customer knew the terms when they bought the program, the terms are not integrated within the contract of sale.”
An EULA (or “break-seal” license as you term it) and the GPL are completely different things. An EULA is a license which places conditions on the usage of the product. It does not include any consideration and, as such, may be invalid as you pointed out. The GPL, on the other hand, does not in any way restrict the usage of the product. As a matter of fact, it explicitly says you don’t need to agree to it to use the software. Copyright law says that only the author of the work can create copies, derivative works, etc. The GPL is a license which provides additional rights to anyone who accepts the license. So there is consideration, you follow this set of terms and in return you get to redistribute, modify, etc this work. If you don’t like the terms, you can feel free to attemp to negotiate a different license or you can use different code. You cannot, however, claim that you didn’t read the license or didn’t agree to it before modifying, redistributing, etc. Well, you could, but in that case you’d be willfully infringing on the copyright of the original author which isn’t a good thing to do either.
Anonymous (IP: 61.95.184.—) wrote:
> NO. Linus has granted no exceptions. what he has personally
> clarified is that he doesnt intend to sue such people and
> considers it legitimate as long as they dont derive code .
> but he is not the significant copyright holder and has
> obsolutely no control over some other kernel developer
> deciding to sue the guys developing such modules.
So in other words, Linus allows it, which is what I said. It’s true he isn’t the only copyright holder, but so far the others are, with voiced concerns in some cases, following his leadership position.
Err wrote:
> That all depends on how I wrap this theoretical library.
> If I wrap it using function calls that get imported into
> my proprietary software then there’s a problem. But if I
> wrap it in such a way that B is standalone and
> communicates with C in a client/server fashion (Eg via
> shared memory/pipes) then A’s code is never linked to my
> code in C.
Is it me, or do the meanings of A and C keep changing?
Lets just call them lib, wrapper and app for the sake of clarity. If you wrap the lib in the way you describe so that the closed app isn’t linked to either the lib or the wrapper then you would be in the clear. It’s a pretty unlikely scenario though. Assuming the original lib is non-trivial (if not you’d just re-implement it right?), you’d end up with a pretty messy situation, stuff getting piped left right and centre. From a technical standpoint you probably wouldn’t want to do it, but legally you’d be on firmer ground.
> The reason I’m thinking this way is that the net is
> effectively one long pipe. No linking ever takes place,
> there are seperate applications passing information, but
> there’s no way (IMHO) information passing can result in
> derived work status.
Absolutely, which is one reason the FSF is working on GPL v3, to extend the reach of the GPL into the web application realm, as was discussed here a couple of days ago.
flimflamman – don’t believe a word of it
“So in other words, Linus allows it, which is what I said. It’s true he isn’t the only copyright holder, but so far the others are, with voiced concerns in some cases, following his leadership position.
”
linus cannot allow something above what the license allows. thats my whole point.if its under gpl, it under gpl. period. there is no “legal” status to what Linus says or believes to be true. there is no leadership here to determine who can decide to sue. so what Linus believes doesnt have any effect at all in a court scenario. if this was a contract then it would have been different. since gpl is a license it should be independantly tested in court regardless of what one of the copright holders feel about it
Linus can allow anything he likes with his code, he could release it under a closed licence if he so wished. Other developers with code in the kernel have the same rights over their code, and at some point someone may take a different stance. As I said though, so far they’re following Linus’s lead, which is why nobody is being taken to court over binary only kernel modules.
Before you talk about what you can and cannot do with GPL’d code, you should probably talk about what the FSF can enforce.
Everybody uses GPL’d software in proprietary, closed-source software and nobody fears any kind of retribution from the FSF or anybody else.
The FSF, Stallman, and his cohorts are a paper tiger. We’ll continue to use all sorts of GPL’d code because we can.
Until I see someone actually being forced to open up their code because of a court mandate, then it’s pointless for me to even consider the GPL or any other similiarly licensed software anything except a giveaway.
What a joke.
Enough about this wrapper, say I write this:
A gpl’d socket server that links to gpl’d code.
A closed source client wrapper that mimics calls to the gpl’d code through messages sent to the gpl’d server.
A closed souce application that makes calls to the wrapper client.
Bam, circumvented gpl. Maybe not super-efficient, but it would work.
The FSF can only take action in cases where they hold the copyright, it’s the holder’s right to pursue suspected copyright violations, nobody else’s.
Nobody has been forced to comply with the GPL by a court decision, for the simple reason that it hasn’t been necessary so far. Many cases of violation have been uncovered, and in every case of which I am aware the violator has been persuaded to come into compliance, without need of a court case. There have been injunctions, but they aren’t final court decisions.
Why do you suppose they would come into compliance voluntarily? Some have been big companies (Next Computer and Linksys for example), with ready access to capable lawyers. If the GPL is such a paper tiger why didn’t they fight it in court? Simple: their legal advice told them it wasn’t a smart idea. The GPL is a very solid licence, the fact that nobody has been prepared to fight it in court should to tell you something.
The joke would appear to be on you.
” By flimflamman (IP: 81.168.127.—) – Posted on 2004-12-01 00:14:14
Linus can allow anything he likes with his code, he could release it under a closed licence if he so wished.”
of course. but his opinions on what GPL means have no legal weight. so once he has licensed his code under GPL, what GPL restricts or allows is the only thing that matters. got my point?.
so whether he feels that binary kernel modules are allowed are not have obsolutely no effect whatsoever for other developers who have their own opinions and can choose to sue the proprietary developers for deriving from their code or whatever if they feel so
We could care less what linksys or anybody else does. The GPL is a joke. Everybody knows it. It’s violated all the time and nobody can do anything about it. There’s lots of cases that have been uncovered where nothing has been done, because nothing can be done unless the copyright holder is willing to go to court, and even then it’s questionable whether the GPL is even legal. Until the legality of the GPL is even proven thanks for the free code in our closed-source apps.
Everybody uses GPL’d software in proprietary, closed-source software and nobody fears any kind of retribution from the FSF or anybody else.
Well, they should, because if they aren’t accepting the terms of the GPL, then they are in violation of copyright law. The penalties for copyright infringement – particularly for the purpose of commercial exploitation – are fairly severe (and getting worse).
It’s not the probability of getting caught which should be giving people reason to pause, but the consequences (there’s the moral issue as well, but since IMHO businesses are inherently amoral at best, that’s really not part of the equation for them).
Until I see someone actually being forced to open up their code because of a court mandate, then it’s pointless for me to even consider the GPL or any other similiarly licensed software anything except a giveaway.
That wouldn’t happen. Most likely scenario would be a massive fine, reparations to the copyright holder(s) and an immediate cease-and-desist to distributing the copyright-infringing code. A reasonably clued-up judge might offer the infringer the choice between that or GPLing their code.
There’s lots of cases that have been uncovered where nothing has been done, because nothing can be done unless the copyright holder is willing to go to court, […]
I’m not completely up on US copyright law, but isn’t gratuitous, commercial violation of copyright law a criminal offense ?
[…] and even then it’s questionable whether the GPL is even legal.
It doesn’t *need* to be legal. If the GPL is found to be invalid, and nullified, you’re still (significantly) in the wrong because you’re violating the copyright of the developers (probably for commercial gain).
Until the legality of the GPL is even proven thanks for the free code in our closed-source apps.
Good luck with that attitude. I hope for your sake you don’t get found out, because if you are it will probably send you bankrupt, at the very least.
“We could care less what linksys or anybody else does. The GPL is a joke. Everybody knows it”
thats a total lie. It has been enforced effectively for more than a decade. search google for “enforcing gpl”
iptables developers even had a successful verdict on *court*
Re: Until the legality of the GPL is even proven thanks for the free code in our closed-source apps.
Oh really, if you are so confident please post your name/the name of the company you work for and the project you borrowed code from. Then, we will contact the developers and let them know that you knowingly violated their license and copyright of the code. Then, when they sue you for copyright infringement for a commercial purpose (which is a criminal offense I believe) and you lose, we will all be proved right.
Unless, of course, you are too scared to do so because of the fact that you know the GPL is a valid license.
Who wants to bet on whether this guy actually posts the info or not???
“Who wants to bet on whether this guy actually posts the info or not???”
He’s a troll. Nothing more. But he does make a good point though. We always have to hear how Open Source is supposedly stealing all its ideas from Closed Source, etc. But nobody can check to see if the opposite is true. A company could very well abuse the GPL and how would anybody ever find out unless it’s blatantly evident. From what I’ve seen, the FSF only sues the companies who apparently haven’t even read the GPL before they start using the code or who maybe just don’t plain don’t understand but use it anyway.
Re:He’s a troll. Nothing more.
Lol, you’re right, I shouldn’t have added that last thing in. Anyways, I just thought I might add, if you are truly stealing code from open source, not only is it morally wrong, it is just downright pathetic and you deserve to be caught. Although this is kind of a bad reference, but it is almost as pathetic as stealing from a charity. Although I doubt someone who would make a statement such as
“Everybody uses GPL’d software in proprietary, closed-source software and nobody fears any kind of retribution from the FSF or anybody else.”
even has the intelligence to write a program, so I’ll let it drop. If it is true though, I’m still waiting for your info if you wanna test the GPL 😉 Very few companies are willing to risk copyright infringement, whether it be with BSD, GPL or Closed Source code as the risks make it not worth it.
http://www.agedwards.com. Go ahead and try to stop our GPL “violations”. Nobody fears open sores geeks.