The "you'll be forced to give away the code" fallacy is not just FUD spread by GPL haters. I've seen plenty of GPL advocates make the same remark, except they say it's a good thing.
I mention this because the linked article strongly implies that only evildoers would ever spread untruths about the GPL. The GPL is long and complex and the FSF's own guidelines to "clarify" things are anything but clear.
I find the FSF FAQ about the GPL (http://www.gnu.org/licenses/gpl-faq.html) extraordinarily clear. Have you read it? It covers lot of the common questions people ask, including how GPL and non-GPL code interact from a legal perspective.
I've pretty much always found that every GPL argument (and I've dealt with a lot of them, having worked with GPL-licensed code in commercial products for over a dozen years) is settled by simply pointing someone to the correct portion of the FSF documentation.
Yes, Open Source and Free Software fans often don't understand the license or its implications, and more people are woefully ignorant of its meaning and purpose than actually understand it, but I don't believe the blame can be placed on the FSF documentation on the subject. As licenses go, it's pretty plainly spoken, and as clarification of licenses go, the FSF goes into extensive detail for anyone that wants to actually look into it rather than starting flame wars based on whatever crazy notion someone has about the GPL and what they want it to mean.
I really don't think the blame can be placed on the FSF in this regard. People just don't RTFM, especially TFM for licenses.
That is the document I'm talking about. I think their answers to questions about derivative works and whatnot (basically the "how do I violate the GPL without getting caught?" questions) are not entirely forthcoming. I can't fault them too much for this, as providing a truthful and complete answer would amount to being a guide to circumventing the GPL which is not in their interest, but the questions and answers are carefully phrased to avoid answering the real question you're probably asking.
There is more wiggle room than the FSF would like people to believe (although it's probably also less wiggle room than those people hope for).
Perhaps I'm just a GPL fanboy, but I don't see how it's a failing of the FAQ to provide a very clear, and understandable, path to not violating the license. And, I don't see how documenting a strict and good faith approach to following the license is in any way in conflict with the original article.
If you read the FAQ (and the license), and follow the terms clearly laid out therein, you can't possibly be in violation of the license and you can't possibly put yourself in a situation where you accidentally force your code to become Free Software (though that's a nearly impossible outcome, even if you don't understand the GPL on any level, which is the point of the original article).
The FAQ even truthfully covers the situations wherein a company might want to use the GPL for a Free Software version of their code while also retaining copyright and offering other licenses (I've had to refer to this particular FAQ many times in flame wars about my own products over the years, since I always hold the copyright on the products I'm dual-licensing, and I use the GPL for the Open Source releases), and while the ethical position of the FSF often creeps into legal discussion, the facts are still quite clear.
I'm not sure I understand why the "real question" would be "how can I use this code without distributing it under the same terms I received it under?" Aren't we assuming good faith on the part of the "victim" of the GPL?
Frankly, all the flame wars about the GPL and the FSF always seem motivated by something other than lack of clarity about the license. They seem based on disagreements with the motives of the FSF, and I find it disingenuous to make it about the license (which is clear to most people who actually read it, and among the best documented software licenses in the world for those who can't grasp its nuances merely from the license itself). If you don't like the Free Software concept, and think BSD or public domain or something else is better for you, or your business, or your customers, or whoever, then say so. Don't argue that the GPL is incomprehensible or the FSF is trying to hide facts about the GPL (the documentation for the GPL v3 is very enlightening and transparent about loopholes in v2 they've tried to close and their reasoning for the changes and additions to the license), as it really isn't.
If someone wishes to circumvent the GPL and thus disrespect the will of the generous developers who made their work available under the sole condition people don't disrespect the rights of users, I have to wonder what are they doing in the software business and whether the software business wouldn't be a better place without them.
You are not "forced to give away code" any more than you are forced to use whatever others built and generously made available to you as a starting point or as a building block under the condition you are no less generous.
Feel free to reinvent as many wheels as you like to keep for yourself.
The reason "you'll be forced to give away the code" probably comes from the circumstances where taking down a product while rewriting all GPL parts from clean table is a worse problem, financial or otherwise, than GPL'ing the whole source code.
Given that you wish to keep using the GPL parts, too, then the truth really is that you will be forced to give away your code. It seems that many do. How many times have you seen in the news that "Initech taking their MongrelSuite(tm) off the market for the time being because of violations of the GPL" versus "Initech forced to relicense their MongrelSuite(tm) in open source due to viral GPL licensing"?
From recent examples (Apple AppStore, Sony, Nintendo), products are usually pulled from the market rather than re-licensed, so your argument doesn't hold.
The article starts off reasonably. The first sentence pulls you in, describing the case you fear most: you have "inadvertently" incorporated GPL code into your proprietary code.
But by the time it gets to the conclusion,you, the inadvertent infringer have become a thief. If found to be infringing, "you do have a choice under the GPL license: you can stop using the stolen code and write your own, or you can decide you'd rather release under the GPL."
Hey! The presumption of the article was that I inadvertently infringed. It was an accident. "Stolen" has a different connotation.
If I inadvertently infringed, I might have peppered that GPL code throughout miles of my own code. The "choice" might be no choice at all, in practical terms. Hey, you could always choose to go out of business.
This article reinforces the claim it purports to refute: that infringers "can be forced to release their proprietary code under the GPL".
No defending infringers mind you. Just saying, the article seems to confirm that the FUD isn't FUD after all.
"If I inadvertently infringed, I might have peppered that GPL code throughout miles of my own code."
Really? You "inadvertently" used miles of code copyrighted by other people without bothering to understand the license under which you obtained said code? That's a stretch. Even if you don't understand the GPL, as a developer with knowledge enough to locate the code you must understand that copyrighted code is probably made available to you under some terms that you must comply with.
Whether you buy a license to use the code, or received a license for free, you can't possibly be a computer programmer with zero notion of what "license" or "copyright" means.
"Just saying, the article seems to confirm that the FUD isn't FUD after all."
The FUD is that once you've introduced GPL code into your software, no matter how small a piece or for what reason, you could be forced to GPL all of your proprietary code. That's simply not true. If, on the other hand, you used so much GPL code that your product can't exist without it and you can't possibly rewrite the violating code, and you did so without putting forth any effort to understand or comply with the license under which you received the code, the best result I can think of would be for your company to go out of business.
Don't address these rhetorical questions to me, using me as a straw man. I didn't assert people are spreading FUD about "inadvertent" infringement. The author did.The author uses "inadvertently" right in the first sentence, as the very premise of the article. So get out of my face with your lecturing.
It's all there in the first sentence of the article. : his definition of "FUD" , the "inadvertent" infringing premise. My criticism is that the article fails as a self contained piece of reasoning. It convinces me the FUD spreaders could be right.
You've picked apart the use of one word, "stolen", used seemingly in place of "inadvertent" earlier in the article. You haven't refuted the logical premise of the article in any meaningful way. This isn't a smoking gun refuting the point of the article.
The fact is that inadvertent infringement, such as someone copy/pastes a few lines of code from GPLed code without awareness of its origin, does not impose a requirement on the entire work. It merely means you either rewrite the offending code (call it "stolen", "borrowed", "misplaced", "inadvertently copied", whatever you want), obtain the code under a different license from the original author (this is entirely plausible, and I've sold licenses in the past in this way on code I held the copyright to and licensed under the GPL), disable that feature, stop distributing the code entirely, or whatever you want to do. You simply are not forced to GPL your code, and it's FUD to suggest that a license would somehow force you to do so.
I'm not saying the article is the best written or most coherent defense of the GPL ever, but its primary premise is correct. You can't "accidentally" GPL your codebase by incorporating a piece of GPL code.
You don't "inadvertently" spread GPL'd code all throughout your codebase, unless you're one of those people who just copy-paste code from the internet everywhere.
The more likely scenario is that you start an open source project. Put it under the BSD. Great. Two years later someone comes and says, remember dev X, Y, and Z. They were using some GPL code in your project. We've found at least 50 instances of it.
Now here's where it gets ugly, because everyone who picked up your project thinking it was a BSD project, just picked up a GPL project. They may be using your code in very intertwined, fully in compliance with the BSD license, but you must now inform them that the must comply with the GPL or cease using this code, or pay damages.
That doesn't seem like a great situation to be in.
Although it is ironically a good argument for the GPL... "sure the license may say MIT/BSD, but it might be GPL"
You don't care about the clarity of the license, or the availability of clear information about what it means, or the fact that the FSF recommends every project that is under the GPL include a complete copy of the GPL in every distributed copy of the code so that it is not inadvertently used by someone that might not know the license. You only care that it's not the license you prefer.
"The more likely scenario is that you start an open source project. Put it under the BSD. Great. Two years later someone comes and says, remember dev X, Y, and Z. They were using some GPL code in your project. We've found at least 50 instances of it."
I've been an Open Source developer for more than a dozen years, on projects in use by millions of people, and under more than a dozen different licenses including BSD and GPL. Some of those projects span hundreds of thousands of lines of code and hundreds of contributors, in both purely commercial and purely non-profit organizations and everything in between. I've never once seen an incident of GPL code being accidentally used in a situation where it caused a license problem. I have seen people try to get away with not following the license, but that's not the same thing, and it was not a misunderstanding or inadvertent.
In short: He (or she) who writes the code, determines the license. Deal with it. If you're using the code it's your responsibility to understand the terms under which it is made available to you. You can't make it the author's responsibility to choose a license that meets your desires. The author of the code presumably has their own desires, and they supercede yours.
He (or she) who writes the code, determines the license.
I don't think anyone disagrees with this. I think some people feel that they're not comfortable with GPL code. It's odd because I've literally had devs at conferences yell at me because I've said, "nah, I'll pass, I don't use GPL". Just as the author of said code determines the license, I'm free to pick software that uses a license I prefer. I'm 100% fine with people using a GPL license. I'm just not fine for me using it in my code.
And I think its fair to say that no one should be abused for using a license of their choosing, and likewise one shouldn't be abused because they don't use software/code that uses a specific license.
>>He (or she) who writes the code, determines the license.
>I don't think anyone disagrees with this.
You picked a minor point that was just a part of his train of thought to get to his real point? Really?
>I think some people feel that they're not comfortable with GPL code. It's odd because I've literally had devs at conferences yell at me because I've said, "nah, I'll pass, I don't use GPL". Just as the author of said code determines the license, I'm free to pick software that uses a license I prefer. I'm 100% fine with people using a GPL license. I'm just not fine for me using it in my code.
You are having an argument that nobody started (except yourself).
>And I think its fair to say that no one should be abused for using a license of their choosing, and likewise one shouldn't be abused because they don't use software/code that uses a specific license.
You are argueing against your own experiences - which are not the topic of this discussion, are not verifiable for us and don't add anything but saying "I didn't like this one time when somebody was rude to me".
Actually, I have no idea what you're trying to say at all.
You literally dedicate half your post to this issue. Your first large paragraph is about me "prefering a license". Then you go on to give your OS qualifications. Then your conclusion is this point.
Here's a hint. If it's a "minor point" don't open with it and then conclude with "In short:" -- and finish it off with the same point. Whatever.
You're having a conversation with two different people. I dedicated half of my first paragraph to the issue. skore is who you're responding to in this comment, who has different opinions (valid ones, but they differ from mine).
I do not think that the author's right to choose their own license is a minor point. It think it's absolutely core to everything about the GPL and licensing and copyright in general. The author's right to determine how their work is used is pretty much the most important point.
And, honestly, in my opinion, and the opinion of the law, it makes all other arguments moot. The law is on the side of the creator of the work, and I believe ethics is on the side of the creator of the work, as well. If the creator of the work wants it to be licensed under the GPL, and you disagree, as far as I'm concerned your only ethical response is to not use the code, or write your own and license it however you see fit, or negotiate with the author of the work you want under a different license. As I've mentioned in other threads, I've sold BSD and commercial licenses of my code in the past, and I currently use a dual-licensed model for my products, and many others have done the same over the years.
One other point I've made elsewhere in this conversation, but I'll make again here: Damned near every flame war about the GPL, which this has obviously devolved into, tends to be not about the clarity of the license or whether it can force people to license their code in ways they didn't want (which is what the original post was about, in case anyone has forgotten). It's simply that some people do not like the GPL and disagree with the FSF and its motives. That's fine. But don't pretend you don't understand the license, don't obfuscate the meaning or capabilities of the license to claim that it can "infect" code or that it is "viral" or that a BSD project can accidentally become GPL. That's just more FUD. You aren't "infected" if you use GPL code without abiding by the terms of the license. You are simply in violation of the license, and you have many means to remedy that situation, and no one is going to force you to release all of your code under the GPL, and no one has any legal method to cause you to do so. Code does not magically become GPL just because you accidentally included some GPL code.
That was the point of the original linked article (which is what we're discussing here, let's not forget), and a point I've tried to make clear all along, in various ways.
I mentioned above, but I'll briefly mention it again: this problem is not limited to GPL. Proprietary code being distributed in a BSD app is just as likely. It's not an issue with licenses. The code might not even have a license, in which case it can't be distributed.
> They were using some GPL code in your project. We've found at least 50 instances of it.
You can replace GPL with any license out there, and it could apply. Heck, you can even violate BSD code by putting it into a GPL app and have the exact same problem.
Perceptive or not, it's not an issue with the GPL. Someone can come back to you with proprietary code inside the same BSD licensed project. Or proprietary inside a GPL. Or AGPL inside GPL. GPLv2 inside GPLv3.
You make assumptions when you use code you didn't write. It's as simple as that. You assume that the distribution of the code is proper, and that the license is as described, and that everyone who contributed did so honestly.
Proprietary or open, it's a problem everywhere, and not limited to just the GPL.
If all you've done is copy-paste stuff from the internet everywhere, then you haven't actually written any code. Regardless, that's not the point. Including GPL code doesn't magically obligate you to release the rest of your source code free to the world - you always have the option of, say, not distributing your program until you've removed and rewritten all the GPL-licensed stuff.
I'm really not sure what you're getting at with your 'viral and inadvertent' comment - it almost seems like you're willfully ignoring the points being made in reply to your comments.
The responses all have the theme, "Inadvertent? Who would do that? Only irresponsible ninnies would do that." So they ignore the premise of the article, which presumes that inadvertent inclusion does happen.
Additionally, I posted a few examples below where otherwise responsible contributors to a codebase might leak some GPLd material into the codebase. Over a long enough time, with enough developers contributing to your codebase, it's inevitable.
"Not distributing your program", for a business, may mean a lot of money. It might mean bankruptcy. How do you know it will be affordable to replace the offending code? The author said "inadvertent", not "tiny".
That's the viral part. GPL source code is all over the net. Any developer on your staff could look at something on line and derive some code from it, and drop it into your codebase. You'll never know about 99.9% of it.
>"Any developer on your staff could look at something on line and derive some code from it, and drop it into your codebase"
Well that's what's so crucial about having solid Best Practices and hiring good developers. If you hire people who break the rules (deliberately or accidentally, with your knowledge or without), then there's your problem. The GPL has nothing to do with that scenario, it's you hiring people who can't toe the line.
I'll reword it for you. Well have a Special class. We'll pay an instructor to come in and give our devs a half day course on How not to Violate the GPL. GPL is another bureaucratic hoop to jump through, just like race and gender discrimination classes. Cost of doing business.
No, you need systems in place to make sure you don't commit copyright infringement. But if you do commit copyright infringement, there are solutions other than opening up your code, such as buying a license from the guy you copied from or removing the infringing code.
look at something on line and derive some code from it
Thankfully, copyright does not protect ideas, only the expression thereof. In this context I take the word "derive" in an informal rather than legal sense (i.e. "derivative work"). If there's only one way to, say, clear the non-blocking flag of a file descriptor, save a couple of variable names, then a developer finding that one way in some example code online and using that method in their own code can't reasonably be considered in violation of copyright law or any license.
How many programmers you know would accidentally include GPL'ed code into proprietary apps that get sold to other people? Is there any documented case of such accident?
I think, a lot. Here's a nifty little FFT code. Hey FFT's are kind of generic, right? This one's only 40 lines of C. I'll just copy and paste this one little function. Nobody'll ever know.
Or maybe nothing so complex as an FFT. Maybe it's a little code for charting. Who knows. Developer picks it up a snippet off the net somewhere, and it appears in your code base.
Then there's "derived works". Developer uses some working code snippet as a starting point, transforms it, specializes it, does a lot of work to it, but it's still derived work. I don't think developers think of it as plagiarism. Just "freedom". ;) But developers don't always protect the best interests of the company.
There is no excuse to simply copy someone else's code without some kind of permission, be it a charting tool, be it a CFD library. If the code is under a BSD-ish license, it's fine to use it. If it's GPL-ish, the developer wants me to honor his conditions and, so, that's what I'll do.
Developers should care about freedom, but also for respecting the will of the developers that built their materials.
> Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
> Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
Fail to do either of these things, and you run into the same problem you would have by not complying with the GPL.
We may be splitting hairs here. The point is that you are free to use BSD code in your closed application without incurring the risk of being asked to choose between removing the code or open-sourcing the whole thing, which is the fear of some.
I imagine they don't mind complying with BSD terms.
"Copyright (c) <year>, <copyright holder>
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
* Neither the name of the <organization> nor the
names of its contributors may be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
"
--
Provided you properly credit the authors of the code you use, which you should be doing anyway, how do you run into problems by using BSD'd code in GPL'd code?
Any reasonable charting code is far more complex than FFTs, of which there are basically only two ways to straightforwardly implement. Of course there are lots of complications you can add such as cache-awareness which change that picture, but that's probably not 40 lines of C (though 40 lines is far more than necessary for a simple FFT)
I think we're getting a bit hung up on semantics. It happens all the time if you mean "accidental" in the sense that companies don't usually say "Hey! Screw the GPL! Let's pirate GPLed software!" The Software Freedom Law Center says:
"As we have worked to bring individual companies into compliance, we have encountered numerous violations resulting from preventable problems such as inadequate attention to licensing of upstream software, misconceptions about the GPL’s terms, and poor communication between software developers and their management."
On the other hand, if you mean "accidental" in the sense of some programmer saying "Honestly, I didn't mean to call that GPLed code. My finger must have slipped!" ... then I hope I don't have to point out that isn't realistic.
Bare licenses (e.g., a license that is not really a contract) are revokable. If Groklaw and Moblen are right, the copyright owner of GPLv2 code can un-GPL the code. This is covered in Rosen's book on open source licensing, and is one of the reasons he recommends making sure your software licenses are in fact contracts.
"All rights granted under this License are granted for the term of copyright on the Program, and are irrevocable provided the stated conditions are met."
Edit: Ah, you said GPLv2, my quote is taken from v3. Looks like they fixed it.
In such a case promissory estoppel would be a very good defense. Distributing your work under the GPL is a strong indication that you intend others to build on it, and their reliance on this is reasonable.
In which case you've essentially got a contract, with promissory estoppel serving as a substitute for consideration.
It's interesting that if one searches, in either law textbooks or in the case law, there just isn't much that makes a distinction between licenses and contracts outside of real property law, where they are usually talking about bare licenses. In almost all other contexts, the terms are largely used interchangeably, although it seems license is more likely to be used when it is a one to many arrangement (e.g., one party is making essentially the same contract with numerous other parties) and contract is more likely when it is one to one.
I doubt you can do this with whatever license you're using unless you put that explicitly on the terms.
But I'm no lawyer and neither a GPL advocate, I'm only interested understanding licenses.
EDIT: I understand that the previous distribution license is revoked only if you fail to comply with the original term under which you agreed to use the software/code.
A court of law might find that there was an unwritten contract agreed to when they let you download the code under the GPLv2 in the first place. I can't see any other way to view such a transaction.
Of course, IANAL and AFAIK this has never been tested.
Yeah, it's annoying if I'm installing something and the installer treats the GPL (or MITL) as a EULA. I don't have to accept/agree to the terms to use it.
You do require a license from the copyright owner to use the software. The installer is just informing you of one such license that is available to you, and the conditions of that license. It is also usually the only such license, unless you have negotiated separately with the copyright owner.
This is one point over which there is some controversy. I would argue that a copyright owner merely distributing software gives one the right to use that software as it was intended, just as distributing a book gives a recipient the right to read it. A license can only restrict that right, or grant additional rights one would not have under copyright.
The GPLv3 preemptively deals with potential counterarguments to this point of view by explicitly affirming the right to use the software, but using reductio ad absurdum, it seems ridiculous to be able to distribute a work under the protection of copyright law without implicitly giving the lawful recipients of the work the ability to use it as intended.
There are plenty of examples of commercial software that is distributed by the copyright owner free-of-charge, but requests agreement to a conditional license during the installation process.
I believe that in the US, this relies on a court ruling (sorry, no cite) that as the use of software inherently requires making a copy of it, such use is a copy right. This is unlike the case of a book or a painting.
There are also examples of commercial software distributed free of charge with no license agreement whatsoever. I sincerely hope that the decision that using software is a "copy" right not implicitly granted by its distribution is overturned, as the notion is truly ludicrous.
That doesn't necessarily mean that EULAs would be unenforcable; one could still argue that the license page of the installer is an effective access control mechanism between the user and the software, possibly invoking some twisted interpretation of the DMCA.
...and I hate that I feel like I have to put this, but as I mentioned elsewhere, IANAL.
I mention this because the linked article strongly implies that only evildoers would ever spread untruths about the GPL. The GPL is long and complex and the FSF's own guidelines to "clarify" things are anything but clear.