Slashdot Mirror
Ask Slashdot: GPLed code with non-GPLed output
redhog asks this question dealing with the
viral nature of the GPL:
"I have a program that interprets a set of
documents, and outputs text according to the
commands and text in this document. The output
consists partly of code hardcoded into the program.
If the program is GPLed, then that part of the
output would be, too. Here is where the problem
arises: The program must be able to generate
proprietary output from proprietary input,
and it is technically impossible to separate
the program and the code being output. Is it
possible to GPL parts of a program? The
best would be if the program (including the
code that is output) was GPLed as a program,
but its output not; i.e. as long as the code
to be output is in the program, it is GPLed,
but as soon as it is isolated, it is not
(And may use a BSD-style license). Is there
any way to acomplish this?" I think I
can clarify this a bit. If your interested,
hit the link for more.
What I think redhog is describing is similar to a situation like this: A GPL'd program is designed to take input from a macro or markup language and convert it into another macro/markup language. To facilitate this conversion, the program defines its own macros, which are included in the output to simplify matters (this is the hardcoded portion that can't be removed from the GPL'd program). Can proprietary output be built on the included GPL'd macros? Or will the viral nature of the GPL extend to the whole output violating the IP of the corporation using it?
It's pretty clear that the 'output' of a program is not restricted unless there's a special exemption in the license. Otherwise, anything you wrote with AbiWord would be GPL'd, anything you wrote with MSWord would belong to Microsoft, etc.
[...snip...]
This is rhetorics. In reality:
Which is more viral ? And this is not a theoritical case, but a very important fact of life for Linux and *BSD developpers: Linux has borrowed some *BSD drivers, and the *BSD couldn't use Linux one's (even *BSD drivers improvements in Linux). I don't say it is bad, good, shameful, great, that it is that way. I just say that it is completly clear that the GPL has "viral" aspect, which is totally independant to the moral evaluation whether it is a good thing (as RMS thinks) or not (as some BSDites think).
If you don't believe me, then imagine I'm releasing some code under the "Slashdot General Public License" (SGPL), which would be exactly identical to the GNU GPL, except that any reference to FSF/GNU would be replaced by "Rob Malda".
Then although the two licenses have identical properties, I could not use SGPL-ed code with GNU GPL-ed code. Why ? Only because both have a viral aspect, and want the code to be released under their name and terms, which is not possible.
Autoconf explicitly states that the program is covered by the GPL, but that its output is not. That simple. Its output consists of quite a bit of stuff from Autoconf itself, so it's a perfect example.
Someone correct me if I am wrong, but couldn't you just comment that some portions of the code are LGPLed and the rest is GPLed. Like this
//BEGIN LGPL Code
//END LGPL Code
//foo.c
//Some Free Software
//This code copyright 1999, someone here or there
//Code in this file is released under the GNU
//General Public License version 2.0,
//with the exception of WELL COMMENTED code
//fragments clearly marked between "//BEGIN LGPL Code" and "//END LGPL Code"
int main
{
SomeFunc();
SomeLGPLFunc();
return 0;
}
Sean Upton
sean@sltrib.com
Why Not? Any thoughts?
I would recommend that SOMEBODY consult with a lawyer, someday. The grandstanding around these topics gets ridiculous sometimes.
As of Bison version 1.24, we have changed the distribution terms for `yyparse' to permit using Bison's output in non-free programs. Formerly, Bison parsers could be used only in programs that were free software. The other GNU programming tools, such as the GNU C compiler, have never had such a requirement. They could always be used for non-free software. The reason Bison was different was not due to a special policy decision; it resulted from applying the usual General Public License to all of the Bison source code.
Beware, Nugget is watching... See?
No. That's bullshit. Please stop lying.
And remember, the only things the GPL seeks to prevent are evil things anyway. There are some side-effects, but they are just a regrettable consequence of trying to stop the proprietary software industry leeching code from free software.
Obviously you didn't read my comment properly, otherwise you would have noticed that I said that the GPL prevents many things that aren't evil, but this is a regrettable but necessary side-effect of make preventing things that are evil.
Your terms are not quite fair. "Infecting as much software as possible" draws in the mind a picture where the GPL is some sort of foreign body, jumping from code to code, using it for its own purposes and to the detriment of the code. You might believe the "using" and the "detriment" parts of the above, but the "jumping" part is clearly false. No one forces you to GPL code, or to use GPLed code. No one restricts you from writing the software you want, and using it however you wish.
The FSF's goal is that it be possible for everyone to do anything they want in their computers without having to use proprietary software, not that every program be GPL. The GPL is a means in this scenario, not an end.
If you want to talk about the FSF's non-free software, let's talk about the fact that for anything to be considered part of the GNU Project, the author must assign the copyright to the FSF. He couldn't even relicense it under a free or proprietary license if he wanted! That doesn't seem too free to me.
No one is forcing anyone to assign copyright to FSF. In fact, I'm sure the vast majority of GPL software is not copyrighted by the FSF.
There are also no scare stories as far as I know of the FSF abusing this (abusing as in not giving credit, or releasing proprietary versions)
The fact the FSF requires this is, IIRC, that they wish to be able to defend the copyright of all programs oficially in the GNU project on court. You know, if they took some GPL program they didn't have the copyright over, and someone violated the GPL on that program, if they're not the copyright holder the FSF would have no business in court.
About the charge of the GPL being "non-free", its refutation is brought up all the time here on slashdot and elsewhere. Freedom does not simply mean "being able to do anything one likes". There is an important restriction on freedom, which is that you are not free to restrict other's freedom. This is precisely the aim behind the GPL-- that no one can restrict your freedom to use the GPLed software.
Anti-GPL advocates tend to give undue emphasis to the only superficially paradoxical fact that one has to impose restrictions on software to keep it free. It should be mentioned that this is merely a tactical choice implicit on the GPL, not something essential. When the state imposes by force a system for some to take away from others what the FSF believes is a freedom, the FSF is forced to protect the users of its software from state protected, private monopolies on formerly free code.
---
This is simply false. From the GPL:
As you can see above, you must accept the GPL _only if_ you wish to _modify_ or _redistribute_ the program.
---
Eh, this does not infringe upon my ability to speak-- only upon my ability to be heard, to which I only have a right under special circumstances (i.e., I have a right to be heard in a judicial proceeding against me).
It could infringe upon other persons right to hear me. For example, you might that way infringe on the right of the public to be informed, if they want to hear me.
This is essentially why campaign funding limitations were declared unconstitutional.
A sad affair of situations, indeed. "Everyone is equal, but some are more equal." This distorts the political arena in favor of the powerful few.
Freedom may have some 'unfair' consequences - and therefore might not be the 'best' solution, but that doesn't mean that we should redefine freedom to mean what ever we believe is the 'best' solution.
Who's redefining freedom?
The concept of freedom I cite has a very long tradition. It is the concept of freedom subscribed to by religious organizations like the Catholic Church (and surely others whose philosophy I dont't know well), and political theories like socialism and democracy. It is often cited as the reason for the establishment of the state, for example: the function of the state is to ensure freedom for its citizens. And this, in turn, is a common argument for law: we need laws to protect citizens' freedoms to be violated.
The idea of "doing whatever one wants", without taking into account the impact of one's actions on others' freedom, has also a name: libertinism. I would argue that the people who go about crying that the FSF is redefining freedom are the ones who actually are redefining it to mean only 'libertinism'.
Let me make my argument a bit more precise, so as not to be misunderstood: the word 'freedom' has several meanings; the one that the FSF chooses has a very long philosophical and legal history, so it is a very legitimate sense of the word 'freedom'. The FSF makes clear that they use freedom in this sense. The argument that the FSF is redefining freedom is therefore not only unsound; it also sins from attempting to purge one of the meanings of the word 'freedom', thus actually commiting that fault which it purports to find on the FSF. What the argument wishes to be the meaning for freedom is covered precisely by the word 'libertinism': that free software be free of the restrictions that the FSF finds that lead to the original freedom being revoked, so that the proponent of the argument be exempt of the social responsibilities that the FSF believe are the counterpart to free software.
---
While you hit on the best position (IMHO) to hold on this issue, I think you are missing some of the subthemes of the flamewar... That of the GPL "not being free", and that of the people who whine because they cannot do whatever they want with other peoples' code. Jeez.
Happily, one finds people on the BSD license camp like you who don't go about whining that they should be able to take others' GPL code proprietary...
---
Huh? Tell me precisely which "rights" the GPL reduces...
And in my book, telling the whole world "I'll share this code with everyone, if everyone shares their changes with everyone" increases freedom. The result is that everyone is free to share the code.
---
I don't think this was the original poster's point (although the smiley is acknowledged). There are two particular strains of anti-GPL argument. One is the altruistic "I want everyone to be able to use my free code for whatever they wish"; the other one the egotistic "I want to use everyone's free code for whatever I wish". I think the poster was attacking position number 2, which I think is the one which causes the most flames.
I prefer the BSD approach. There is nothing morally wrong with GPL; releasing software under any free/open license is an act of generosity. But to me, the BSD license corresponds to my own sense of the word "freedom", which means allowing people to do things of which you disapprove.
I don't think the more reasoned GPL advocates really have a major issue with this (in the sense you give above; that they would think it, rather than an act of generosity, to be morally wrong). And if some of them happen to do, I think they're wrong.
---
No, it doesn't. For the simple fact that there is no such right, so no one can "refuse" it to you. (My question was a rhetoric one.) I was responding to a guy that claimed that the GPL "reduces your rights"; which quite simply runs contrary to the fact that the GPL is a license, and therefore, it licenses or allows you to do some specified actions.
That's its job; I'm not unhappy with that, because I agree entirely that proprietary is immoral. However, this reduces freedom for programmers.
So it prevents people from doing a certain kind of immoral act (by your own concession).
Worse, the GPL also explicitly prohibits my linking a non-GPLed program with a GPLed library (even if the program's open source).
This is simply not true. If your program is a separate, independent work from the GPLed library, then you may distribute your program under whichever license you wish; what must be distributed under GPL is the combination of the program and the GPLed code.
In fact, there are non-GPL programs out there that can use GPL libraries. The programs usually don't _require_ the specific GPL libraries they link, but if you have them installed, you can compile the program against the GPL libs. For example, Python can be built with GNU Readline support. Also Hugs, a Haskell interpreter, may be built against it. (Though I must admit these examples are really devoid of practical significance. I just point them out to factually justify my correction.)
My math professor wrote a Forth program to play with group theory. He then ported it to gforth (GNU Forth), and handed out the source for his program together with gforth.exe. Stallman called him and ordered him to stop; it seems that he was distributing gforth without also putting its source on diskettes and handing THEM out as well.
I agree this part of the GPL is not nice. Nowadays, since so many people are connected to the net (for god's sake, you are talking about an _univerisity_), these requirements from the GPL seem obsolete in this situation (you could just put the source in the univeristy FTP server and tell everyone they can get it from there). I think this is going to be phased out in the GPL 3.0, though.
Countless other stories could be told, but the fact remains that the GPL reduces one aspect of freedom in HOPE that it will increase the total amount of freedom. Whether that hope is correct or not, the GPL's only actual action is to reduce freedom, both for the programmer and the distributor.
I think you might have the seed of an argument here. I'll have to give this part more thought.
---
This is what I call the 'libertine software' argument. "It's bad, because I can't do whatever I like with other people's software!"
It's one thing when one says "here's my program, under BSD license; let the everyone do whatever they may with it it." This position, although criticised by GPL advocates (it allows derivative works to be made unfree), at least has some elements of altruism (or at least, sacrifice in exepectation of a greater reward).
But then it's another thing to say "I should be able to do anything I want with free software".
People should really give the Preamble of the GPL a good, slow read. I think it's more than self-explanatory. Freedom for _everyone_ to use, change and share the fruit of the community's work.
I guess you think no one understands the BSD license.
I think I can understand the licensor's point of view: "Here, I wrote this, you can have it. Do what you like with it, I want you to benefit from my work".
However, the point of view of some licensees is what's problematic, IMHO. I mean the same thing I said above, libertine software: "A program is free if I can do whatever I like with it."
Contrast this with the FSF ideal, which I will paraphrase (in my terms): "The ideal for a piece of software is freedom for _everyone_ to examine, change and share it."
---
Even if you output *is* considered to be covered by the GPL (which I doubt, see all the other posts) the solution is easy. The GPL does not FORCE you to distribute GPL'd code. So if you had something that would be GPL'd but wanted to keep it proprietary, simply don't distribute it to anyone outside your company. If you did distribute it, then of course you would have to pass on the freedoms of the GPL.
Since (assumedly) your company owns the output, not you as a person, you could distribute it company wide without giving any employee the freedom to distribute it outside the company.
And then there is:
And finally a little explanation of "derivative":
--
The world is neither black nor white nor good nor evil, only many shades of CowboyNeal.
Isn't this a little like asking if you can use a GPLed compiler to create a non-GPLed program?
...phil
...phil
"For a list of the ways which technology has failed to improve our quality of life, press 3."
One can easily understand why You don't like the word "viral" (as: "it infects it's neibourhood with GPL"). Word "virus" is usualy mentioned in a negative conotation, and "viral" == "good" usually needs some explaining.
I suppose, "imune", as in "it is imune against beeing infected by non-free licences" would be a better word. Maybe we should start clasifying free licences according to their "immunity".
Enslavement is the wrong term, I'm sure; but submission is correct, I believe.
In order to use GPl'd programs, just as with Microsoft programs, I must submit to an onerous license restricting my freedom. In that sense, it is (as I'm sure the original poster meant) indeed oppressive.
Don't get me wrong, I ultimately don't mind using the GPL because the FSF's heart is in the right place, and the moral qualms are not very significant; especially in light of the fact that the GPL has actually accomplished its stated goal of protecting free software from ceasing to be free software several times.
However, I am an idealist who looks forward to a day that the GPL is cast aside in favor of everyone "simply" sharing their code.
--Matthew
Excuse me if, in my current state of occasionally peeking at the code of programs on my system and even sometimes (the horror!) taking snippets of code from them for use in my own projects, I consider modification and distribution a part of "use."
Yes, I know that I can still run the program, but I can still run a program under Microsoft's EULA. I am less restricted by the GPL, but still in some ways onerously restricted.
To rephrase the statement you found to have a legalistically erroneous turn of phrase, "In order to use the code of GPl'd programs as I am wont to do, just as with Microsoft programs, I must submit to an onerous license restricting my freedom."
I hope that has clarified things so that you don't think I'm some idiot with no understanding of the GPL, but rather some idiot rarely interested in making his language appeal to lawyers (just professors of English).
--Matthew
Stephan
If it's your own program, there's no issue here. You can apply whatever licenses you choose: GPL, GPL with exceptions, BSD, proprietary... Note that I said "licenses". You, as copyright holder, can apply different licenses to different forms of distribution. You could GPL it for general use, and sell a version under a proprietary license with bundled support. You could give your company special exemption from the existing license rules, if that's what your intent is.
I am a lawyer, but this is not legal advice. See a lawyer in your own jurisdiction if you need some.
This is *ancient* contract law in the english speaking world. The particular overrides the general; the addendum overrides the boilerplate.
Put in a preface, suffix, or extra file, and anything in it that contradicts the GPL overrides those terms, and the rest of the GPL remains intact.
Or, claim to release it under the GPL, but take actions inconsistant with the GPL, such as having dependencies upon GPL-non-assimilable code, and encourage people to distribute binaries. Your actions then override the GPL and modify it, for a quasi-GPL (QGPL?) license. THere are tons of those out there, many calling themselves GPL when they're not, and they don't even know it . . .
hawk, esq.
Dammit, you beat me to it :-)
Absolutely right - *don't* hardcode it.
This is what "resource files" are for. Though sometimes maligned, they can be useful.
If you *insist* on hardcoding, you could have the snippets of output stashed in static array(s) of strings allocated in a separate source file, then put that source file under a BSD or MIT -like license. Then link this into the GPLed program.
Problem solved. The data could be statically linked into the same binary, and yet still be completely unaffected by the GPL or *any* other license the rest of the program might be under.
-- Mike Greaves
This seems easy to solve - without any exemptions to the GPL.
It would seem you either need to read in, or link in source files which fall under a more liberal, but GPL-compatible license.
See "resource files or static arrays" posted below.
-- Mike Greaves
"But if you consider denying the right to own slaves to be an advancement why don't you see the same progress in software made by the GPL?"
/because proprietary software isn't slavery,/ any more than copying licenced software is theft. (It's copyright violation, not theft.)
Good question. The answer is:
Both are bad. Neither one is the evil that its opponents claim.
Prop SW (unlike slavery) forces nobody to do anything. It can't. In fact, its disutility is so high that for many people, an otherwise inferior freeware will displace it (freeware in the sense merely of freely distributable _binaries_).
-Billy
I did imply that the GPL enslaves people. That was an example of sloppy rhetoric, and I apologise.
The GPL doesn't enslave people; it merely reduces their rights. It also claims that it's increasing people's freedom.
It lies.
The BSD or XFree or Python licenses increase freedom across the board. THEY are the licenses which result in freedom. If the only alternative to freedom is slavery, the GPL _is_ slavery. Of course, that's nonsense, but that's what the GPL promoters say all the time.
In fact, the only reason to use the GPL is because you prize pragmatism about principle.
-Billy
The GPL refuses the right to do silly things like make changes and distribute them in a proprietary manner.
That's its job; I'm not unhappy with that, because I agree entirely that proprietary is immoral. However, this reduces freedom for programmers.
Worse, the GPL also explicitly prohibits my linking a non-GPLed program with a GPLed library (even if the program's open source).
And even worse, the GPL mandates specific forms of distribution which put even _users_ in chains.
Let me explain that last paragraph.
My math professor wrote a Forth program to play with group theory. He then ported it to gforth (GNU Forth), and handed out the source for his program together with gforth.exe. Stallman called him and ordered him to stop; it seems that he was distributing gforth without also putting its source on diskettes and handing THEM out as well.
But what could he do? He wanted to get other teachers to hand these programs out to their students, but that would mean that they would also have to understand the GPL and be willing to distribute gForth source.
Even though his program was completely free of restriction, he wound up not being able to use it.
Countless other stories could be told, but the fact remains that the GPL reduces one aspect of freedom in HOPE that it will increase the total amount of freedom. Whether that hope is correct or not, the GPL's only actual action is to reduce freedom, both for the programmer and the distributor.
Again, I like the rest of the GPL, and I think that other licenses do its job much more morally. XFree and BSD, for example.
-Billy
The first rule of licenses is that whoever makes the code makes the rules. So you're safe if you're allowed to make the license -- just use the GPL and attach a clause to it pointing out that the output is considered a derivative work of the input, NOT of the Program (or something similar).
The Artistic Licence is written with this in mind for even very complex transforms. You might take a look at it.
And finally, I dislike the GPL. It has a VERY good goal; but its means to that end are repressive. I don't want my software free if it enslaves people.
My ideal license is BSD-style (minus the attribution clause), but I would make the special note (not in the license) that I did not want my program to be used in a proprietary system.
Moral people are free to use my program in moral ways; I'm not concerned about the behavior of immoral people.
-Billy
People use GCC to compile proprietary software all the time (thus including GCC-generated code in the output), and so far as I know that's OK.
--
--
Yes - RMS once took offence at my use of the adjective "infective" when describing the GPL, despite the fact that I meant it in a descriptive, not pejorative sense. I quickly s/infective/inoculative/. We should chose our adjective wisely -- even if WE know what we mean, the great unwashed do not, and it is best to avoid getting sloppy in our words when our audience might get the wrong idea.
In Liberty, Rene
I'm not sure that I like that.
On the one hand, I support the idea that those who want to make their software free should be able to restrict what those who don't can do with the fruits of their labour.
Producing a non-GPL readline(), unless done without any knowledge of GPL readline(), is likely to be a cheap stunt of takeing GPL code non-GPL. I presume you did not do this, and you have every right to reimplement that particular function and license it as you wish (as opposed to some free software zealots who would like non-free code to be illegal).
However, if the ONLY reason you produced a non-GPL readline() was to impede efforts to encourage freeing up code (by those who wanted to use readline() but had non-free code), then that's simply spiteful.
I would like to see more code freed up, and I do think that in some cases, the "all or nothing" approach of the GPL hurts. The LGPL, on the other
hand "gives away too much" to benefit producers of non-free code. I wouldn't mind an LGPL interpreter from being used in some application, for example, but I WOULD mind someone creatively extendeding the interpreter, and closing off the extentions.
Unlike RMS, who believes that free software licenses should not only keep existing code free, but prevent it from being used with non-free code in redistributed derived works, I do think that in some instances offering a "carrot" under certain conditions to purveyers of non-free code wouldn't hurt the free software community. However, sometimes the LGPL is more of a carrot than I want to offer
I also think that integrators of code should be able to have free code take advantage of (but not necessarily the reverse in most circumstances) non-free code. Hell, that's how most free code was bootstrapped into being anyway. While relying on Qt (under the old license) might not be wise, forbidding the combination of free code with a non-free library until a free one was available isn't wise either -- even if it encourages development of a free alternative sooner.
RMS might argue that one can always structure the non-free part as a library, so simply giving carte blanche to linking from free to non-free code isn't a good idea in general, but doing so makes the interface to the library open, and makes production of free alternatives easier.
In Liberty, Rene
I don't actually have a real solution, but this is exactly the situation bison is in. Since bison includes part of itself in its output, the programs it outputs have to be GPLed as well. This is why most distributions include both yacc and bison, which have very close to the same functionality. Yacc has a BSD license and can thus be used for projects where bison cannot.
It was/is my understanding that the GPL license is only for protecting the source code of the program. So if I write a program foo and somebody wants to add something to the code they can't turn around and start selling the foo binaries as proprietary software. But if somebody takes program foo and uses it to create some other entity bar, then bar is free and clear to be anything the creator of bar wants it to be. Perhaps I'm missing something or have a misunderstanding of the question, but that's how I see things.
If I decide to write proprietary software using Linux and gcc, there's nothing in the GPL that says I can't do that. And from what I understand this scenario is very much the same situation.
Sean
RFC2119
When I read the quandry, it seemed to me there is an obvious way to avoid the issue. Why not just NOT hardcode the output-included bits in the GPL main program. Instead, standardize on an external supplementary data file that contains all the inclusions, say 'proprietary_bits'. The main program can just read the relevant parts of proprietary_bits into variables, then use those dynamic contents instead of anything in the object code itself.
I suppose this approach might have a slight performance penalty, but it should not be extreme. Even if proprietary_bits rarely or never ACTUALLY gets changed, it could in principle, so it really is data rather than code. And data doesn't get contaminated by the GPL.
Yours, Lulu...
Buy Text Processing in Python
Bruce
Bruce Perens.
I used to write "affect", as in "to have an effect upon", but too many people objected to that usage because of its secondary meaning, which has to do with emotion. "effect" when used in its verb form has the same meaning, anyway, look it up.
Whatever form I use, "effect" or "affect", someone always comes along and tells me it's wrong and I should use the other form.
Bruce
Bruce Perens.
This beats arguments about the GPL any day.
Bruce Perens.
I hope that answers the question.
Thanks
Bruce
Bruce Perens.
Your metaphor is invalid. People who sell add-on parts don't make copies of my car and sell them.
Bruce Perens.
I'd say it matters to the end user whether I write the code or not. I'd not write it if the BSD license was my only protection.
Bruce Perens.
I can't help but see that as a fair trade. If somebody wants to use my GPL-ed code, they have to GPL what they are using it with. I wrote it to add to the existing pool of free software, not to help anyone with free consulting services for their proprietary stuff.
Bruce
Bruce Perens.
If I decide to write a program and contribute it to free software, the GPL assures me that it will stay free software forever. I'd be bothered if somebody made it non-free, effectively stealing my work for their own remuneration. The GPL is effectively a vaccine against that.
The BSD license lets people apply almost any license to my software, including most non-free licenses. If I wrote work under the BSD license, someone could modify it and sell the result with no source code, and I'd have no recourse at all. Anyone who wants can infect my BSD software with the non-free license virus.
So, which license is more viral? It sounds to me as if the GPL is getting a bum rap here.
By the way, the BSD license allows you to apply the GPL to a modified BSD work. I've thought about organizing a GPL-ed thread derived from the body of existing BSD-licensed work, just to illustrate a lesson about the BSD license. That would really piss people off, but it would be legal.
Thanks
Bruce
Bruce Perens.
Thanks
Bruce
Bruce Perens.
everything you encoded with l3enc would belong to Fraunhofer IIS. Now wouldn't that be fucked up? (Ok, that's a slightly different issue)
--
Fuck the system? Nah, you might catch something.
You are missing the point of the GPLed output. The idea is to prevent someone from taking GCC, patching it with a flag that dumps the entire source of gcc as a tarball to stdout and saying "It's the output of the program! Now it's under any licence I chose!".
Hence, compression, encryption or rot-13ing the strings dosn't change anything. --Dan
The term "viral" carries so many negative connotations that it's highly unlikely that a joint and insightful understanding of GPL vs. BSD can be reached as long as people continue accusing each other of it.
Drop viral. It doesn't help us move forward.
"The question of whether machines can think is no more interesting than [] whether submarines can swim" - Dijkstra
Really, the source being GPL'd won't make the programs output GPL'd because it's _not_ a der. work of it. Basically anything that a program outputs during normal use is _your_ work. For your hardcoded data to remain GPL'd someone whould have to be using _onother_ tool to copy it with.
Note: This is true for the GPL, there _are_other_ licences too.
FRA: STFU GTFO
Maby you missed the "someone whould have to be using _another_ tool to copy it with" part. Cat is by my definition an _other_ tool than the linux source. Programs that output such a significant portion of their _own_ source code that their output can be considered to be a der. product naturally aren't covered by "Basically"!
FRA: STFU GTFO
this isn't rocket science. go look at bison's info page, see the "conditions" section.
US Citizen living abroad? Register to vote!
* As is generally the case, my opinions do not reflect those of my employer.
-- Faré @ TUNES.org
-- Faré @ TUNES.org
Reflection & Cybernet
Whoops, I meant for that to be in the main thread, not a reply to this one (which I missed, somehow). Sorry.
(Disclaimer: I'm not a lawyer, but I think I have a decent understanding of the GPL).
What about gcc? I haven't taken a look at the sources, but I'm sure that somewhere in there (maybe in the data files, which are also placed under the GPL), there's pre-defined stuff that ends up in your executables. But you can legally create closed-source binaries with gcc. My understanding is that this is because your programs aren't a "derivative work" of gcc (search the text of the GPL for the full legal mumbo jumbo), even though gcc is a vital step in making closed-source binaries. The same should apply to your program. But this could all be thrown out the window if your program has some complex macros that're statically shoved into the final works (e.g. you CAN'T legally produce closed-source binaries with ANY compiler if you statically link with a GPLed library).
Also, I just realized there's a flame war waiting to burst out about my semantics: in this case, I'm using "closed-source" as a synonym of "non GPLed".
ORBit basically says "The idl compilier is GPL. The code generated by it has no restrictions"
I would think a similar disclaimer is all that is needed.
Almost all programs produce output which came from the code itself. Compilers -- all that output comes from within, not from the source they process. There's an html mode for emacs -- it adds a section all form within itself. Gnuplot - outpust lots of stuff which didn't come from the data files.
I've got a program which reports temp probe readings to the screen. The digits are fabricated from external data, but the decimal and the F/C are hard coded within the program.
I find it hard to believe anyone would consider those outputs GPL'd.
--
Infuriate left and right
You are right that BSD-licensed code can be released and re-released under different free and proprietary licenses, whereas GPL'd code cannot except by the copyright holder.
Bruce is saying that from his point of view as a hacker interested in writing free software that many people will use and improve, the idea of using a BSD license is bothersome. If his code is used in a proprietary product that is more popular than the original BSD-licensed program, its usefulness to him as a force for good in the world is diminished. By a stretch of metaphor, he calls this capacity for diminishment "viral".
On the other hand, from the point of view of someone who wants to use other people's software in a proprietary or unrestricted (e.g., BSD) licensed product, BSD-licensed code is a boon. When such people find a bit of code on the net that might aid their enterprise, they look at the license (if they are scrupulous) hoping to see the "Redistribution and use in source and binary forms are permitted" line of the BSD license and dreading the words "You should have received a copy of the GNU General Public License". Such people tend to call the GPL's self-propagating quality "viral".
In other words, it's all in how you look at it.
[Just a side note, this thread is off topic, but the original question has been answered quite thoroughly (use a special exception to the GPL), and we all like discussing license politics.]
The GPL does not apply to the output of a program unless the output "constitutes a work based on the program" [sec. 0], where this clause is clarified further up as being defined as the Program or any derivative work under copyright law. Although it's unlikely the author could get away with claiming copyright on your output because it contains a portion of his work, it's really up to the author how to interpret this. If you're really worried, ask the author to insert a clause like the exemption bison's license gives for the bison skeleton, and have him re-license it to you. If it's your own program, you can do whatever the hell you want :)
I've finally had it: until slashdot gets article moderation, I am not coming back.
don't give them any ideas!
And, BTW, saying '...or you're all lame crackers/nukers which is what I suspect anyways.'...well, okay, I won't call you a troll, but that won't change whether you are or not. :)
Who's immature here, me or you?
If corporations are people, aren't stockholders guilty of slavery?
cjs
The world's most portable OS: http://www.netbsd.org.
Disclaimer: I am not a lawyer.
This is a very simple situation. It's exactly analogous to both GCC and bison. Both programs are covered under the GPL, and both take input, which is used to generate output. As mentioned, the GPL doesn't even try to claim the output of a GPL-covered program is necessarily covered by the GPL.
Because GCC performs a translation job, the output is covered by the GPL only if the input file (the program you're compiling) was covered by the GPL. (I think there are some tiny routines that can get pulled in automatically by GCC from a library compiled by the system's native compiler, but as I recall, those were placed in the public domain.)
Bison is a different story; a key component of the output of bison is the parser, which is copied from a template file that bison uses. Because the template was under the GPL, the output was a derived work, therefore under the GPL. (The current release of bison now contains a special provision in that template to exempt bison output from the GPL.) Anyone could have used bison (any release) legally to generate proprietary output from a proprietary input file -- provided they rewrote the parser template and used it instead. Since yacc was available, nobody bothered...
So, the solution to original poster's situation is simple; extract all the code that needs to be exempt from the GPL and put it in a template file (or several) with a different license, or as public domain. Use GPL for the program code, but not the template. If you don't hardcode the template information into the GPL program, it doesn't have to infect it.
Deven
"Simple things should be simple, and complex things should be possible." - Alan Kay
Why does some of the code need to be hardcoded? Why not just put the hardcoded part that is to be outputted in a file and read it in from the program? That way the file wouldn't have to be GPL'd. Seems like a simple solution. My guess is that your trying to avoid this.
My sig has a broken link in it.
this should be solvable.
I'm unfamiliar with the exact terms of the GPL, but it seems that a simple compression scheme could get around this problem. Pre-compress your fixed output, then pass it to a decompression routine at runtime, so that the output itself is not found anywhere in the code. If this is illegal, then isn't *all* output from any GPL'ed program also GPL'ed?
Shame, shame, shame on you for hardcoding a piece of a product that should be configurable. What if you want to add a new macro (let's call it that for now) to the system?
:-) Make the code read those definitions in from another file. Put 'em there. Easy.
First off, take any of those definitions you say can't be removed and remove them.
Failing that, modularize them into procedures, put those procedures in another file, then #include it.
Failing even that, replace the important bits with keywords, use #defines to replace those bits, then #include the #defines in another file.
There is ALWAYS a way.
May the force be with you.
- Give a man a fire and he's warm for a day, but set him on fire and he's warm for the rest of his life.
From the GPL 2.0:
/usr/src/linux/COPYING file (thats the one that comes with the Linux kernel) states:
"The act of running the Program is not restricted, and the output from the Program is covered only if its contents constitute a work based on the Program (independent of having been made by running the Program). Whether that is true depends on what the Program does."
I think what Bruce Perens says about putting a disclaimer makes sense. In fact, my
"NOTE! This copyright does *not* cover user programs that use kernel services by normal system calls - this is merely considered normal use of the kernel, and does *not* fall under the heading of 'derived work'."
I hope this answers your question...but remember:
DISCLAIMER: I am not a lawyer. I would recommend consulting one if you are really serious.
My journal has hot
He would need a termination clause of some kind in his original BSD license to be able to do that.
BSD and MIT licensed code isn't propietary, though. What exactly are you trying to say?
People like this post just to get attention. Why is everyone encouraging him by posting repl... uh... never mind.
--
Do I look like I speak for my employer?
GNU copyleft covers
... does this mean an unencrypted command can be automatically sent to a server outside the US, encrypted code added, then forwarded to a third party without breaking any export laws?
1) copying/distribution OK but must keep GPL license
2) modification/derivative works iff acknowledged + nondiscriminatory relicensing & redistribution
3) binaries OK iff source provided directly or indirectly
4) even if you screw up, your audience can do what they want so long as they don't screw up
5) above terms accepted if you modify/distribute source
6) can't deny others the same rights
7) if patented, can't distribute
8) if distribution blocked, allow geographical exclusion
Therefore if you generate the output through a web interface, you are not redistributing the original source, just output (although it would be smart to reference the original software). Hmmmm
What a wierd world we live in.
LL
As I understand it here is your issue:
You are writing Program A that needs to generate Program B. b1...bn (some subset of B) is identical to a1...an (some subset of A).
This is no problem, assuming you are the creator of A. As creator you hold the copyright for any code you create. Here is what you do:
1) Create a file containing s1...sn (the subsets that need to be in both programs)
2) Fork the tree on those subsets, make one branch GPL and the other whatever you want.
3) Include the GPL fork in A and the non-GPL fork in B.
Remember, the copyright holder can re-release GPL'd code as non-GPL.
---
Put Hemos through English 101!
Linux MAPI Server!
http://www.openone.com/software/MailOne/
(Exchange Migration HOWTO coming soon)
As I understand things, it's the main copyright holder who can throw in an exception to the GPL (or some other license). If a group of people hold the copyright, they probably flame themselves on their private mailing list for a few days, and then make a public decision. :)
The history of Bison, as I understand it, makes this fairly interesting. IIRC, Bison was derived (by Richard Stallman, et al) from a Yacc which had a Berkeley style license. After he made his changes, he put Bison under the GNU GPL. People had concerns about Bison's output being automatically under the GPL, so the exception that Bruce mentioned above was introduced.
But what I'm curious about is what happens in a circumstance like this: J. R. Hacker writes a useful program that outputs some code. His useful program is under a BSD style copyright. I like his program, make some changes for myself, and put the new bit under the GPL. With my new souped up version, the outputted code is also under the GPL, because I want it that way. Now... can the program's original author, J. R. Hacker, preempt my licensing decision and say that output from the program, even my version, needn't be covered by the GPL?
There's a lot of potential for confusion here. My proposed solution? Make all software free, everywhere. All of this licensing crapola would go out the door. Everyone would be happy once the dust settled. It wouldn't send anyone into the poor house, either. But we all knew that.
You're a suburbanite.
I believe this is exactly why parts of bison and flex were put under the LGPL (which RMS is crazy to deprecate). The parts of the code which are inserted into output are allowed to be linked to by non-GPL programs. This may not be legally the same, but it's certainly analogous.
I refered to "rabid" anti-GPL people, so was not in fact constructing a straw-man. :)
I know Stallman's definition "free" is dubious; I tried to make clear just how silly I think it is. But the rabid anti-GPL people get trapped by the same mangled rhetoric buy claiming tha BSD-style licenses are somehow more free than the GPL.
It has nothing to do with free speech, because the ability to share code is not the same as the right to express oneself. In the context of patents and export laws, the analogy is somewhat applicable, but not with general issues of intellectual property. Look at this way, I have the right to write a book/program criticizing the government, but I still own the words/source and can restrict its use within certain bounds.
So forget about vague rhetorical ideals, look at what the licenses accomplish. One license is simply more restrictive than the other, because they have different goals. One promotes a small community and guards against exploitment, the other promotes a larger community and doesn't care about exploitment.
There is nothing wrong with not wanting to be exploited; it is the very basis of intellectual property in the first place! This is my I get so irritated by anti-GPL people, because their most frequent objection is to the fact that they can't use GPL'ed code and still retain exclusive rights. They support this with talk about "freedom" only because they can't admit they want something without paying for it. TANSTAAFL
I'm not claiming that the GPL is better, nor am I criticizing BSD style licenses. Use the one that fits your goals. Personally I like the LGPL because it balances all these issues.
So it's whoever writes the most code get's to set the license, is that it? So if I steal your proprietary code and add twice the amount of my own, it's all mine then?
I don't think I'll ever understand the convoluted logic of these rabid anti-GPL people. First they claim that the GPL somehow coerces them into making their software free, then they claim that people who make GPL software don't really believe in free software anyway.
Let's break this down: anti-GPL person believes in property rights, but anti-GPL person chastises someone else for using them, as if he is somehow entitled to that code.
And it always seems to be the ultra-capitalist, Ayn Rand worshipping types (i.e. strong property rights, unconditionally) who push this view. I may be going out on a limb here, but I think this
has nothing to do with freedom and everything to do with a hatred of Stallman and his success.
So get over it already! Sure Stallman's a fanatic, but so are the people trumpeting the so-called BSD Linux. In Stallman's ideology, GPL is in fact free, because his ideology regects proprietary software altogether. In other words, it's free because it's free for the GPL community. Maybe you want to squabble over the definition of "free", but that still rhetorical hand-waving every bit is pointless as Stallman's.
You don't like the GPL not because it isn't "free", but because it doesn't jive with your interests. You see this huge body of available source code, but can't have it because of licensing restrictions. So you whine and compain about how "not free" the GPL really is.
Anti-GPL people, let me put this in terms you understand: Stallman's rhetoric aside, GPL software does have owners. It is the free software community. The "viral" restrictions exist because we do not wish to be exploited. We work for ourselves by working for the community; when the community creates wealth by making new software, we all get a bit richer.
Now, just because we share does not mean our time is valueless, so if want to use the products of our labor, you damn well better pay for them. The way you do so is to join the community by sharing your enhancements. If you don't like those terms, then you can take your business elsewhere. It's that simple. It you somehow feel "entitled" to the software, then you either a.) reject the notion of intellectual property on philosophical grounds, so the GPL doesn't really affect you, or b.) you are an opportunist who is every bit exploitive as some "collectivist" straw-man from a Rand novel.
So go ahead, write your own code, slap whatever license you want on it. Don't expect us to do it for you.
The only teeth the GPL has is that a user must accept its terms to copy the software, but if the software is already copyable, then the GPL need not be accepted.
If I add a "#pragma abe" to GCC to emit the Gettysburg Address, that doesn't put the GA under GPL, does it?
Exactly.
I think that what are dealing with is a "tool" versus what is done with that tool. To a certain degree, all software programs are tools. They are written to accomplish some goal. Many of these have output. That output should not be covered by the license used for the code.
For example: if you run a Linux machine where you use vi to create file containing your bank account number. That does not mean that your account number is suddenly GPLed. You have the right to decide what you release. If you want to keep it private, you do so.
If this isn't the case, GPL with fail.
This is not a new problem, since for example GCC includes code into the program (crtbegin.o, etc). In gcc it's solved by a license exception in the code that gets included in the output. Check the gcc sources for appropriate wording.
Sure you do. The same copyright law applies to GPL code as it does to proprietary code, with or without sourcecode available. If you're vulnerable to a copyright violation because you havent done a clean-room reimplementation it doesnt make any difference wether the original code is GPL or something else.
IANAL. Whatever.
We live in a world that has laws, and those laws have to be enforced by men with guns. Who's gonna do it. You? You, Lieutennant Weinburg? I have a greater responsiblity.... (appologies to Jack Nicholson)
Seriously, though, laws do not at all make it clear what is right and wrong. Laws make it clear what society will and will not tolerate. There is a very important distinction between these two conecpts. Namely, everyone should be able to (more or less) agree on what the law is. (Which is not the same as agreeing on what it should be). Not everyone agrees on what is right and wrong.
By the way, the BSD license allows you to apply the GPL to a modified BSD work.
No, it doesn't. GPL requires that no other restrictions be made, BSD license requires that it's terms be preserved (which is a restriction).
Thus, you can't apply GPL over BSD.
(8-DCS)
Who says selling an end user a binary only distro is a bad thing? If that's my terms for distro and the end user could care less about the source, then what's the problem?
Sure you should choose the license that makes sense for you. But choosing GPL because of these ethical (and subjective), IMHO is a flawed judgement.
Theo
BSD was set back because there was contention with code from AT&T. BSD was based on AT&T code and as such, AT&T would not allow their code to be widely disseminated (at least in the way BSD'ers wanted).
This required a major rewrite of the BSD's innards. It turned a lot of people off because the BSD's code base was not stable.
ASIDE: A lot of the original BSD work was sponsored by gov't and university funding. In the case of gov't funding, its illegal to put any restrictions on the code.
The other point you're missing is that BSD'ed code can't be "harmed." The entire goal of the licensing that way is to spread the code far and wide. If you as a programmer can use unencumbered code in your projects then go for you. If a company uses the code and sells it to someone willing to pay for it, then go for them. If a user gets a more stable commercial app because of it, then good for the user.
GPL proponents think the original code is some how diminished when it gets closed up. The original code is still there for all to enjoy. Additionally, a company would have to work pretty damn hard to make their closed version more enticing than the free and community supported version. (Really, which would you choose?) If they pull it off, then they deserve their money.
The last point IMHO is that many people adopt the GPL to protect themselves from Microsoft. Really, the only way to protect your code from someone who really wants to take it is to not distribute source at all. In that regard, BSD coders are realists. They know someone will misuse the code.
Anyway, when copyright law was created, it was done to give people the impetus to create, secure in knowing that they would have the chance to benefit from their own work. It's what IP is all about. People want and need to own their creations, especially ones that take a nontrivial amount of effort to accomplish.
I'm not saying don't use GPL or BSD. That's your choice as the developer. And that's the crux. If you do away with the concept of ownership, then you can no more say "this is MY code and YOU can't distribute it without providing the source" than you can say "this is MY code and YOU can only have the binary."
Yep.. and in the case of Licensing Agreements you make the "law".. you say what people can and cannot do with your program.. so hopefully you have some grasp of the ethics involved in making up that law.
How we know is more important than what we know.
The GPL is designed to "let people use your code" as long as they agree to "let people use their code".. yes I am restricting your rights.. I'm restricting your right to be a bastard.. it has something to do with living in a society.
How we know is more important than what we know.
The GPL is about ethics.. What you are saying when you use the GPL is that you will not restrict the rights of others with your licensing agreement. You are saying, if you want to use my program to create another program, do not restrict the rights of others because I consider that BAD.. do not use my program to treat people bad, to restrict others' rights. So if your asking how you can write a program that is GPL'd and helps people do bad things then you're asking the wrong question.. you should be asking: why do I want to use the GPL?
It's time for an analogy (and it's a tired old one): I'm Sony.. I make video recorders.. Video recorders allow people to copy programs off broadcast mediums like television and watch them at some other time than the time they were broadcast.. so called "time shifting".. I think this is a fair and just thing to do.. I add a chip into my video recorder that will turn off the tape when an advertisement comes on because my users don't like advertisements on their recorded programs.. they just fast-forward them anyway.. this too is ok because when the person recorded the program they weren't watching the television (otherwise why would they record it) so they wouldn't have seen the advertisements anyway.. also very good.. someone asks me if I can make a video recorder that records two channels at the same time and blanks out the advertisements on both channels and then plays them back one after the other.. this way you get to see twice the number of programs and no advertisement.. although this is LEGAL, I don't do it.. why? because the intent is that people will be watching the time delayed playbacks at the same time as recording and never see the advertisements regardless of the fact that they are watching television at the time of the advertisements.. this undermines the system used to pay for the programs.. there will be victims (assuming the constant bombardment of advertising on television actually does sell products) to my unit and I will be responsible..
When you write a program you have to make a decision as to whether or not you are going to take responsibility for what people do with it. Do you want people to be able to do bad things to each other with your program or would you prefer that they did nice thing to each other with it. These issues are a little deap for most of us programmers to want to think about.. But one issue appears to be important to us.. How hard it is to write programs. If I am free to go out and find a program that does almost what I want and modify it to do what I want then my programming experience is greater. All I am saying when I put the GPL on my program is that I dont want you to stop me from having these freedoms and maybe I'm saying that I don't want you to stop anyone else either.
In answer to your question, slap a big label on the top of your program that says "anything that has a little tiny bit of my GPL'd code in it is GPL'd baby.. and don't even think of locking it up"..
How we know is more important than what we know.
OK, ok, I know I'll probably go to hell or something for this but I can't help my self . . . Last Post!
Or you could take the separation-of-processes approach the way BSD's bc program does. That's the same kind of approach taken by my freed version of getline().
Then again, was there some reason you had to use the GPL?
One thing every body must keep in mind with the copyright law, is that the intent of the law is to protect a work as a whole, not as snippet of the work.
That mean that even if every line of code is copyrighted in a work, you cannot sue someone if he copied a small part of your code.
Note that the small part is not considered small in regards of the amount of line of codes but as it's weigth in the whole work. For example, in an data compression application, the code related to the compression engine has more weigth that the code related to the UI (because the main purpose of the application is to compress data and not to present a nice UI).
So to respond to the question, if the generated code (wich is hardcoded in the original GPL'd application) will be protected by the license only if it represent a part that weight a lot (functionnaly) in the original code (wich is probably not the case because it is the conversion engine that is the purpose of the application). In the case that the generated code represent a big part of the work, then it would be advisable to use another license (or an exception to the license) for that part.
So "free speech" only applies to those who follow the guidelines. I can only "speak" about the GPL if want to use GPL'd code.
This does not sound like free speech to me. It appears to be a form of censorship.
The problem is that the author (of the slashdot question we are posting to) is _NOT_ the original author of the GPL code. How can he then add components that have "special exceptions"?
Seriously, if he is legally able to add a Bison-like "special exception" to portions of GPL-derived code, anyone use any GPL code and not release key modifications as a "special exception".
I find this post curious. Who is permitted to make "special exceptions"? The author of any derived code?
My understanding is this: The copyright holder has absolute control over the code. Period. The GPL does not apply to the copyright owner since GPL is only one of many ways for the owner to distribute the code. In addition to distributing by GPL the owner *could* distribute the same code under a BSD-style licence, or (horror) sell propietary licences.
That having been said, under GPL what are the dynamics of copyright ownership in derived works? This issue is totally ignored in the text of the GPL.
Are derived works copyright to the original author?
-OR-
Is the copyright for the derived work entirely transferred to the author of the derived code?
-OR-
Is there joint ownership of the code?
Under joint ownership does it suffice to obtain use permission from one of the owners or must permission from all of the owners be obtained?