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?
Use a BSD license. The GPL was written to make sure that proprietary IP is killed off. If you don't agree with that *political* statement, then use a different license, period.
Too many open source developers jump on the GPL bandwagon without thinking about what cause they're helping. My code should only be free if it has no value, but I'm not opposed to showing it to others.
This should be simple. The documents produced on a GPL'd wordprocessor are not necessarily GPL'd and do not fall under the derivative works clause, therefore the documents produced by your GPL'd program are not GPL'd and do not fall under the derivative works clause.
Makes sense.
Several people have already said what you need to do - insert language about a "special exception".
/usr/share/autoconf/acgeneral.m4 (if your copy of autoconf is installed where mine is).
Your program sounds like it works almost exactly the same way Autoconf does. You should be able to steal its licensing language verbatim. Look at the comments at the top of
That should be affecting, not effecting, there's a big difference and you want to be correct since this is a legal agreement. It got a '4' sheesh!
The key role lies on the user who will either accept or refuse to use GPL software. Political statement.., if you take it in this way, almost everything else is a political statement then. I buy a pair of ducks and move to the country; well, that is a much greater political statement.
I know I probably should not even respond to this, but the GNU project has produced so many software tools that make my work a whole lot easier.
If you take a look at their web site you might even find that you have used, or do use their software on a daily basis. If you use Linux, you do.
Their hard work should be applauded.
Replace "static array" with "functions" and "BSD like license" with "proprietary code", and you'll see why this might not be allowed.
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.
Ahem... no names or anything, but a company I was working for a few years back didn't give a tinker's damn about these restrictions, they just used bison anyway.
Your definitions are correct, but Bruce's usage of the word is quite wrong. "To put into effect your copyright rights on those..." is beyond awkward; it's just plain wrong.
No, Bruce. You can't do that. You are modifying the GPL to make it nonviral in this situation. If you can do it here, others can do it anywhere. Which is it?
You sir, are a liar. There is no vaccine. You have absolutely no say over the work of others. You infect them. You tell them what to do. You tell the autodealer he may not charge for add-on parts. You cannot make it true by lying about it. Orwellian redefinition remains a lie.
There's a scheme on gnu.misc.discuss today about removing the virus from GPL'd library code. It's about time.
No, you can do anything you want if you wrote the program in the first place. You obviously can't change the license on somebody else's program, though.
The license for GCC contains a similar exemption for its output.
This is not true. The FSF has no produced this software. Other people have. Virtually the only thing I use from the FSF is the binutils -- gcc etc. The rest is free.
Thanks, Billy, for seeing that the GPL is a form of communism and enslavement designed to hurt some people and help others.
So, which license is more viral? It sounds to me as if the GPL is getting a bum rap here.
I can agree with your main point, I think, but it's not clear to me -- from what's been said, mind you, I don't have the BSD license text handy -- that the BSD license would never allow you to get rid of any parts of the code that were once infected with the 'closed source' genes once you'd decided you want an 'open source' germ line (damn this is getting to be a strained metaphor).
e.g. if you'd gone temporarily insane and yielded up a few binary only releases based on some BSD'd source, then later decided you wanted some coding input from outside the shop, what would prevent you from releasing the source?
On the other hand, the GPL wouldn't allow you to close up any source obtained under it. Once it's GPL'd, that's it. So it seems to me that the traits of GPL'd software are more persistent than any 'closed sourced' BSD'd software.
Not that I understand why anybody would want to work on source code just so others could profit from it ...
The key point is that to the END USER, the license doesn't matter. The fine points of GPL versus BSD only affect the programmer who wants to use somebody else's code.
And for that matter, for all of you who complain about the GPL "virus"- if you didn't write the code, I suggest you stop complaining about what license its author chose.
Good for them. The only sane thing to do in the face of such tyranny and oppression is to rebel.
oh fuck off and write your own damn software.
Bruce is clearly reaching beyond himself. So much for the English degree.
Hmm, it looks like the loons are out around the time of the new moon for a change. Excuse me: but to make your metaphor work, you need to add that Mr. Perens et al gave the dealer permission to use the blueprints -- the product of a lot of planning and hard work -- on the condition that if the dealer modifies the design, he has to make that available to others. The dealer can even sell the cars based on the original design without giving the 'open blueprint' crowd anything. Then the dealer turns around and complains about being constrained by their license. What you say to the dealer is "You got a design for (@$#%& free, remember? No whining about it after you've decided you want to go back on the original deal."
I suppose the dealer would rather have to fork over $$$$ and sign an NDA with a design firm, discuss modifications with them, then have them duplicated by the original design shop without recompense. Oy veh.
Thank you, Tom.
You say he should learn why people say its viral. He doesn't care, you know. Understanding is not the goal. Taking over the world is the goal. I'm not kidding.
I think you're on the right track here except flex is not covered by the GPL and bison is GPL'd and not LGPL. Originally the FSF required programs using bison output to be GPL'd because bison parsers included, in part GPL'd code. The FSF later (much later) decided to drop the restriction. I think a similar answer would address the question being asked here.
That wouldn't piss very many people off. That sort of sharing (incorporating BSDL'd code into a GPL'd project) is an illustration of the primary purpose of the license: to make code that's as useful to as many people as possible, including those who are using different (invariably more restrictive) licenses, including the GPL or some dreaded proprietary license. The license is as lenient as it is in order to make the code as widely reusable as possible, period. BSDL doesn't discriminate. Proprietary licenses exist to serve a financial agenda and the GPL exists to serve a political agenda; BSDL implies no agenda aside from sharing as widely and as indiscriminately as possible. This doesn't make it intrinsically better or worse than other licenses; it all depends on what your motivations are. Don't pretend to flame licenses when what really angers you is the fact that there are people who are motivated by different ideals than you are; that's what this is really about, isn't it? Respect others' ideals a bit more and maybe they won't be so quick to jump all over yours.
You seem to feel that you have no write to the code for the propritary strain, yet you seem to infer that you have some sort of right to use GPLed code. Make up your mind.
It's the author's choice.
IMHO, GPL wins out, because if Mr. Propritary's work completely overshadows yours then I'd agree he has the right to use whatever licence he wants. However, all he has to do is finish he work and ditch your code if it's so unimportant.
So what is it? Do you have the right to use other peoples code in a work that could be made propritary when those other people dont want their code 'stolen'? Do you have the right to force a developer using your code to give back your enhancements? You can't accept one without the other.
You cannot spread a vaccine, Bruce. You can only spread a virus. Get your metaphors straight, and stop lying.
Infection only occurs through bacteria or viruses, not through vaccines.
Either anybody can use GPL code for anything they want, or else it isn't free.
Since Bruce has shown us that we can amend the GPV to make it non-viral, what other changes would be good?
> yeah... no sh*t... if you write the damn code you can license it any way you want... so it's
> "viral" because you can't steal someone's else's code and claim it as your own
Exactly. I'm sick of people complaining about the GPL's "virus" when it seems that most of them are just interested in doing exactly that.
No Bruce never said this, he said something quite different, I'm not sure what he DID say but he never made the original error.
There are so many follow-ups to my original objection (I'm the original anonymous coward) many of them incorrect, but I assure you and everyone else that the original use is wrong and I don't need Webster's to tell me that. The difference in appropriate use of the words is not subtle, it is glaringly obvious.
Please affect the suggested correction so that interested parties may put the statement into effect by adding it to their GPL files.
Cheers,
GPL and BSD code are often mixed in the same _software package_; just because you can't mix every source code file together doesn't mean the two can't be combined.
There is a GNU clone of the proprietary Unix SCCS system, for instance, that consists of GPLed back-end programs called by a BSD licensed front end.
Linux distributions are sold as an "operating system" which consists of nothing other than an intermingling of BSD and GPL code.
The free BSD derivates all effectively depend on GCC.
Enough said.
And do you have any idea how many people's work depends upon gcc?
NO. Again, I'm the original objecter and
1) Your quote appears to have the correct useage of effect.
2) The statement was possibly wrong for other reasons (I'm beyond caring).
3) Even if Bruce wrote that...
4) Go with my original suggestion and use "affecting" and you'll be OK.
5) Why advise othere on rewording this when you don't know have a firm grasp of the useage here? REALLY I'm curious, why?
A program is just a set of instructions to transform data. These instructions are what is licensed. Neither the inputted data nor the outputted results are affected in any way shape or form by what license the code has.
Your data is just fine!
This is why you can use the code generated by flex and bison to write your own proprietary programs without any concern as to the license that flex and bison have.
Your data belongs to you, no program can take that away from you.
*smile*
The question a businessman should ask is "Has the GPL been tested in court?" We can the issues around like a badmitton birdie, but there has to someday be a legal precedent for the GPL to be at all enforcable.
So my question for discussion here is:
Has anybody been sued for violation of the GPL, and what was the legal precedent set when that case went through the courts?
These issues are someday going to be established in a court somewhere, and I for one am tired of the ad nausemum discussion of the issues surrounding the GPL being used as a political platform and nothing else.
It sounds like they were writing their own software. Are you gonna sic lawyers on them, the way a proprietary software publisher would?
I think the GPL is ripe for a major legal challange somewhere. Can anybody cite solid case law where it's been shown to be valid in court?
What is the "GNU Collective"?
Are you implying that when somebody GPLs their work, it becomes the property of some sort of syndicate? If it's based on previous GPL'd code, of course there will be a lineage of ownership, but it certainly doesn't devolve into a stew where anybody who throws a kludge into the pot can draw from the collective work of the individuals who've contributed unrelated code.
Was GCC hand coded in machine language?
What tools were used for it's original creation?
The author didn't "choose" if the work was based on or in any number of ways was "touched" by other GPL'd code.
Let's be frank here. The GPL is one layer removed from the Software Patent. Why should somebody have to 'reinvent the wheel' because somebody happened along and encoded the algorhythm before them, and GPL'd it?
I'm not talking about unique creative new projects. I am talking about plain old utilities like GCC and the other bin utilities.
It seems like many of the 'common sense' ways that people abuse other software licenses (i.e. using a stolen copy of a Microsoft or Borland C compiler, or writing an OS with Microsoft C, which is indeed in violation of their license) get shrugged off, while there's a high-and-holy righteousness whenever the subject of the GCC tools come up.
No, actually they have to be sued by the person who insists they provide the source.
Has this ever happened?
Call your RedHat Account Rep - He can give you a quote.
Ethics has to be nailed down with a body of Law. I'm sorry, but that's just the way it is. Otherwise it turns into a slippery thing that nobody can make any sense out of.
We live in a world of laws. Laws make it clear what is right and wrong. Sure, a warm fuzzy consensual arrangement works in a Temporary Autonomous Zone like a private party or two people in bed. Out in the mean cruel real world there have to be rules written down, or people wind up getting hurt.
You are behaving like a 2 year old. Quit being a TROLL.
There are a few ways to resolve this issue.
- Use a non-GPL license, and simply include a clause that says "this software way, under the users descretion, be distributed under the GNU General Public License." This is what AOL Server did (see their license for an example). This works well.
- Use a mixture of LGPL code for everything except the parts that need to be in the output. Make the parts for the output public domain (I don't know whether other combos of licenses will work, but this one is definitely valid).
- Externalize the macros. This seems like the technically proper thing to do. Stick them in a separate data file.
The first two approaches will not let you use other people's GPL code. The last will.
- pmitros
It is correct. Describe how I can add, for instance, a video compression technique that my company has had a team of people working on for over two years into a GPL program and have it protected.
nada, the only way you can get around it is to patent the software before releasing.
Also, GPL protects the license of the CODE, not the ideas. Someone can look at the code and figure out exactly how it works, then rewrite it and put it under their own license. You do not need to clean-room engineer code under GPL.
Somebody please moderate that shit down.
CmdrTaco, please hack some paranoia into the comment code. It wouldn't be so bad if the colors would change back once the pointer moved off the link.
"please affect the suggested correction" is wrong. You people really don't speak English at all, do you?
What do you mean "Mr Perens et al"? Who's Al?
Chris Bidmead! How the hell are ya? Never thought I'd see you on the net again after you vacated rec.arts.drwho many, many years ago now. (No, you wouldn't remember me -- I was just a lurker, and have long since departed the newsgroup myself).
Just goes to show that geeks just keep clustering around the same old things.
So, uh, do you do the Linux convention scene? If so, would you hold me in utter contempt if I showed up one of these years and nervously asked for an inscription in my Target paperbacks of Logopolis and Castrovalva? (It's not just anyone I ask to sign books, ya know, you'd get to join the esteemed company of Douglas Hofstadter and Steve Jackson...and, if I ever get the chance, Richard Dawkins and Daniel Dennett.)
Well, anyway, I'll stop being a drooling fanboy now and tell any confused slashdotters that Chris Bidmead was waving his geek flag high when most of us were still in diapers. Of course, maybe this isn't news to those who have read his user info, which I haven't, yet...
Apologies for the staggeringly off-topic content.
Branden Robinson, Debian GNU/Linux developer
Now we're getting language lessons from some buffoon who can't even tell affect from effect. Yeah, right.
That if you are allowed to link BSD licensed code with GPL code, then you are allowed to link proprietary code with GPL code.
Probably commercial 'cc', what is your point ? There are out there commercial programs that are orders of magnitude more difficult to develop than most free software (for instance high-level industrial CAD systems).
That's not true. If you do 'cat /usr/src/linux-2.2.10.tar.gz', the Linux kernel doesn't suddenly belong to you. How much work from the program authors, and from the program users, is present in the output determines who is the owner of the final code (both users and authors might be) ; along with what the license of the program says.
All that means is that you can't take a program which someone else wrote and GPL'd, and change the liscense *on that program*. If you write the program, you determine the liscense, and the liscense can be anything you choose, straight GPL, modified GPL, or anything else.
I guess the work aroung for the "Artistic License" works, because it says it distributes the whole package "either as GPL or XXX at your choice", so if you want the "Artistic one", you just pretend all the code is under that license as the authors said you have the right to, and FSF couldn't sue you since there is no GPL code in that case.
No, you don't have to write the whole thing yourself. You just have to write your exception SEPARATE from the document with the GPL license. Thus, instead of writing "This program falls under the GPL, as presented in LICENSE.TXT", you write "This program is licensed under the GPL, as presented in LICENSE.TXT, with the following changes: ...."
HOWEVER, the combined work is under the GPL as a whole, BUT when taken on it's own, the non-GPL'd code naturally still is under it's own license.
Thus it is reasonable to assume that output generated from non-GPL'd data/code would not be under the GPL even if it was linked to GPL'd code.
By default, you are not allowed to use code written by other people. GPL basically says that they grant you the right of redistribution provided you meet exactly their rules. If GPL is not enforceable, then you revert to default: GPL code cannot be used at all. In any case the infringer looses.
These issues are someday going to be established in a court somewhere, and I for one am tired of the ad nausemum discussion of the issues surrounding the GPL being used as a political platform and nothing else.
Huh? Re-read the original post. The question was: "by the rules of the GPL, is the output of a GPL program GPLed". This is not a political question.
GPL-style license is something you can not get around. Once a code is GPL'd and parts added to it by several contributors, you can never get rid of it. With commercial licenses you can at least buy the copyright owner and then do what ever you want if you have the $$$.
:-)
Fine so far, if you make it, you can license it any way you want.
The only problem I can see is this. Once a piece of code is under GPL, it can never be combined with some other code (say, a nifty codec some company developed using a few $100000 man-years) which has incompatible license. Unless of course you are willing to buy out the incompatible license in order to make it GPL...
Maybe FSF should start liberating algorithms... Might not be an impossible thing to do, and it would certainly be very useful. Maybe we'd get things like a free DVD player software eventually
I think they call it collective to make it sounds like communism, when in fact, the GPL is far more pro-business than anti-business. They irony also is that collectives is a solid fundamental concept for shareholders, baseball-owners, partnerships, cartels, etc. All these words are no different than collectives. (Well, I should have consulted the dictionary before I post but it is approaching 6:30am already.)
And my free-software brother in war, would not be better to stop fighting about free vs. THE free software when the war agains proprietary is still going on with so many long fights ahead?
You are getting this wrong. Reverse engineering is simpler with GPL code because it is documented. If you then develop new source based on your findings there is no copyright issue.
Copyright is when you "copy" code. If you rename variables, change function names and add some different control paths then it is not copyright infringement. To be out of copyright infringement you only need to change 20% of the code. That is generally what the law accepts.
GPL talks about freedom, but in turn they "borrow" code and take away your freedom. In clean room, start from scratch applications GPL is fair. But consider the situation of Bison. RMS took a piece of code that was under a liberal license and then put it into a restrictive license because "it suited his means".
Sorry, but RMS is only interested in his own world!!!!
I'm not a lawyer, but that should work as long as you are the author to all the source or the licenses are compatible with each other.
It's allready being done in a number of projects, although they have split up the source into different files with the individual licenses printed at the top of the source for making it all simpler and more clear, but that shouldn't make any legal difference. A number of projects are for example including LGPL:ed libraries although the rest is distributed under different licenses.
However, you can NOT do that with GPL-code that you don't have the copyright to since it would be a clear breach of the GPL to link it against non-free code.
/Tord
I can't believe how naive you are. Apparently you have defined evil to be whatever the GPL seeks to prevent. I'm afraid it doesn't work that way. The GPL prevents many things which are not evil, and just because the GPL prevents something, doesn't make that thing evil.
You, sir, are correct. I should have looked harder at that last sentence: what I meant to say was that I wasn't sure why anyone would want to work hard producing code just so somebody else could tweak it a bit and *not* release the source back for others to use. That is, the BSD license (as I understand it) leaves room for scenarios where only one person has the right to profit from orginally open source code; the GPL makes it possible for anybody to do that.
I believe you're missing the point of the "viral" objection, that being that people are complaining about the way the GPL "spreads" to any code which is added to a GPLed work. A BSD license does not do this.
This doesn't just hurt people who want to make proprietary software, BTW, it also hurts some people making open source software. Consider the situation where a device driver exists in, say, the NetBSD kernel which someone wants to adapt
for the Linux kernel - they are allowed to do this because they can take the BSD licenced code and rerelease it under the GPL. However, the NetBSD people cannot use code from the Linux kernel in their own open source kernel, because it would require them to release their entire open source project under a licence which they are not happy with.
So, don't include my GPL code in your code. This is "my" code I don't allow you to use it that way!
And you can define "free" the way you want, it doesn't matter, my code is not for you!
And, if your code is so wonderful, why the hell you need any of MY code?
>So what is it?
Neither. Consider, as a datapoint, the Tcl language. Tcl is a highly successful open source porduct which is now making money for its authors through the company they set up, Scriptics. The whole point of Tcl is that it gets incorporated into other programs, and the fact that it has been incorporated into a huge variety of closed-source products does nothing to subvert the intentions of the authors; if anything it helps them because Tcl has become a defacto standard. I doubt this would have happened had Tcl been released under the GPL.
The best thing would be to make the static hard-coded portion an input file, like a resource. That way, you GPL the program, your hardcoding is secure, the output is proprietary, and your program is more modular. Just plain old good programming practice if you ask me...
-B
Yes, changing ~20% of the original work CAN get you around the copyright restrictions. HOWEVER, that ~20% has to be MEANINGFUL. Simply changing variable names and the like is no less copyright infringement than taking a copy of the Star Wars script and changing the names of the characters and locations, even if that were somehow that magical ~20%.
- The Mysterious Voice
I believe you're missing the point of the "viral" objection, that being that people are complaining about the way the GPL
"spreads" to any code which is added to a GPLed work.
Does it? My reading of the GPL is that you do not need to change the licenses on the individual source files, only license the *whole* under the GPL. This might seem like a nitpicky distinction, but it means that if you incorporate GPLed code into your project, your code isn't "lost forever" to the GPL (although I believe you do have to include a GPLed version); you can still distribute the non-GPLed code under the original license.
For example, say I have a project with source files foo.c, bar.c, and baz.c. foo.c and bar.c are public domain but baz.c is GPLed. Furthermore, assume I use BSD and thus have a near-rabid hatred for anything done by GNU -- I can tolerate using their software (after all, I'm compiling this with gcc), but my code must not be touched by The Evil License. However, I'm slightly more sane than your average BSDer, and so here's what I do:
(a) license the output program (foobar) under the GPL. But before you start screaming bloody murder:
(b) Leave the licenses on the other source files alone. Therefore, any other libertine software can continue to link against it.
I'd have to scrutinize the GPL again, but I believe it only requires a license change for the *entire derivative work*. It doesn't jump into your other source files and change the license; thus, it is more of a 'dominant gene' than a virus. The mechanism above solves the 'problem' in question -- admittedly, it lets people fork a GPLed version but if you use BSD or public domain you always risk that 'danger' anyway. But I suppose a 'true' BSDer would balk at this.. (I'm getting really tired of all the BSD trolls today who have evidently never *read* the GPL. If I were paranoid I'd say that Microsoft is trying to create tensions amongst free software users. But that seems unlikely. *shrug* )
Daniel
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).
Let me repeat that for you: the GPL requires that no *additional* restrictions are imposed. If BSDs terms are within the bounds of the GPL, you can easily apply the GPL over it. (you are preserving the BSD terms, just adding to them)
Daniel
It sounds like you can't cite a legal precedent.
Why are we wasting time even talking about a licensing scheme that hasn't been tested in court?
quite bean atroll!!
The simple solution is to use a free license instead of the GPL. Why bother with chains and evil?
The simple solution is to use a free license instead of the GPL. Why bother with chains and evil?
(using up those points, moderators?)
Have some kindness of spirit. You're asking Bruce to give up his religion. That is never an easy thing for anybody to do.
Have some kindness of spirit. You're asking Bruce to give up his religion. That is never an easy thing for anybody to do.
(use up 'dem moderator points)
Have some kindness of spirit. You're asking Bruce to give up his religion. That is never an easy thing for anybody to do.
(how many points do you have left?)
Moderate this one up -- it's important.
As soon as the pro-virus contingent drops using a virus, the virus-free contingent will no longer have need of the term.
The pro-virus crowd prefers "inoculative".
The anti-virus crowd prefers "infective".
But it still does the same thing, and it still hurts people.
This one is also important and deserves careful consideration.
It's not "pro-virus" vs "anti-virus". Didn't the abortion wars teach you anything? It's "pro-virus" vs "pro-freedom".
Linux has always been more BSD than it has been GNU. There's very little in any version of Linux (Suse/Linux, Redhat/Linux, etc) that the FSF wrote that isn't just a look-and-feel clone of BSD or AT&T programs. They don't innovate. They replicate.
For one who talks about strawmen, you're doing as pretty good job of constructing one yourself. No-one here seems to be arguing that people shouldn't be allowed to use the GPL, the point is that reprsenting nthe GPL as some pinacle of "freedom" is dubious at best, and probably downright misleading, because it essentially biols down to, "you are free to use my code for whatever purposes you like as long as it's not something that I disagree with". The analogy is with "free speech", where one is permitted to say anything that the government of the day approves of.
If you want yo use the GPL, fine, please do. Just don't pretend it's in any way similar to the idea of free speech, which includes the right to say things which one might disapprove of. The BSD licence grants this level of freedom, the GPL does not.
> The GPL merely insures that code that has been
> made free, remains free -- it cannot even be
> incorporated in a non-free program.
Then it's not free (as in free speech) then, is it? The point about free speech is not to just grant it it people whos aims you agree with, it's supposed to be universal.
Not only can GPL code not be incorporated into a non-free piece of software, it can't be incorporated into many free ones either, such as one of the open source BSD kernels.
Any code which I release in a personal capacity, I put under a BSD style licence because I am concerned about peoples' freedom to use it. That means that someone can take it and use itfor their own, proprietary means, and I may not like that, but that's what this freedom business is about - one takes the rough with the smooth.
> "Successful" by whose definition? If "successful"
> means "profitable", then yes, I suppose it was
> successful. But some of us do not measure success
> by the amount of money brought in. As a language,
> Tcl leaves many things to be desired (from what
> little I've seen of it), so by my own personal
> standard it is not a success.
I'm the poster you're replying to, BTW.
Successful as in it enjoys widespread useage and has brought its authors much well deserved recognition. Your comments lead me to suspect, with respect, that you don't understand it. The purpose of Tcl is to provide top level control flow scripting of underlying programs, particularly enhancing areas which traditional programming languages such as C do not perform well. Those who understand its purpose and the power it dervies from being typeless and essentially a LISP variant (Tcl is almost completely based on list-processing of S-expressions) tend to find that Tcl is very well designed indeed, and complements the purely imperative, compiled languages which it tends to get embedded into very well.
If you're thinking of it as a general purpose programming language, you're missing the point. Look at something like Expect (and DejaGNU, which is built ontop of it) to see the true power of Tcl.
The GPL is the general public license. It is just that; a license that is the right thing for most programs, but certainly not for all programs. This is one of the cases where it's not the right license.
Make your own license, and just add a clause that says the user may also use the code under the terms of the GPL.
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.
This is not necessarily true, think about the most common analogy used - free speech. If I have freedom of speech then this freedom includes the right to scream at the top of my lungs every time you try to speak even though this infringes upon your ability to speak. This is essentially why campaign funding limitations were declared unconstitutional. 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.
bjg
Don't think free speach. Think a free nintendo game, since that's what most linuxors can indentify with.
Holy man, nice attitude. I may be able to define "free" however I want but you sure haven't left much room for interpretation of "free" as you see it: look but don't touch.
So I guess what you are really saying is that you like to release your code as "free" but in fact you don't like the idea of anyone using it and you especially don't like the idea of anyone making any money off of it. The whole thing is sort of like a bad bout of jealousy.
If I can't have it then no one can. So much for being open.
Make a plug-in architecture. Where the conversion shortcuts (which would normally be a part of the GPL'ed program) are external to the program. Then you just plug-in the conversion code and generate the output. Thus, seperating them. May take a little longer to write, but in the end there is a lot of power in starting out with a plug in architecture.
But they aren't at least with what is generally considered as "BSD terms", because of the advertisement clause, see http://www.gnu.org/philosophy/bsd.html. If the advertisement clause was "when you include this in a proprietary (only) you must credit us", this would be ok, but it isn't the case.
Of course in practice BSD code is often used silently in GPL products ; but Stallman says it is wrong.
What about the Fair Use clause in Title 17? Since the code IS copyrighted, simply quoting small segments would be ok....wether or not useing thase segments in a larger code base would be ok I don't know. An arguement could be made that the output of the program would possibly fall into Fair Use though.
To answer your question...any program distributed with anything GPLed or linked TO anything GPLed HAS to be GPLed in that distribution...there are no exceptions. You can distribute a "patch" or something which the user must add to the GPLed package...course once he does its GPLed as a side effect so in your case it would not help because IF the output is GPLed then it still would be.
Yep the GPL sucks. I really adamantly suggest all coders use some *other* less restrictive licence for all free software. I do.
Simple Solution:
DON'T USE THE GPL!!!
Gee, maybe this will show some of you people that the GPL is not The Answer. Although most of these zeolots will tell you that the GPL is the only "pure" license, their are many alternatives. Try, for example, the Berkley License used with FreeBSD. It puts absolutely _no_ restrictions on what you do with your code.
And I find it sad that when another person posted a similar statement as mine, they treated the thought of using something _different_ than the GPL was some sort of blasphemy. Come on, grow up.
I read it on the Internet, so it must be true.
The GPL says you *will* restrict users rights, not that you won't. Otherwise, there'd be no reason to EVER use GPL instead of say, LGPL or Mozilla PL. They don't call it the Gestapo Public License for nothing.
Please don't encourage program authors to use half-measures like the GPL. Either let people use your code, or don't.
I know it's often done, but by what legal theory do people take a X11 (& BSD, etc) and just ignore most of it? It's non-viral in that nothing says YOUR work must carry any particular license, but that doesn't remove any part of the license from modifications (as opposed to "derivations" in the GPL's mangled meaning). It almost makes me wish licensors would enforce their licenses once in a while, so people can learn what they mean. I think the licensors don't know most of the time.
He says he's concerned about fairness, and I do believe that's what the GPL is all about, but there are two problems with that.
First, he (and many others) have no qualms about enslaving BSD/X11/Artistic code derivations under the GPL, in some cases simply to spite non-GPL'ers. (I read of such a plan just today.) They don't understand fairness. They do understand the value of a good lawyer in acquiring power over other's actions.
Second, "fairness" is a highly over-rated thing. The desire for it is the source of many evils including jealousy, hoarding, and vengeance. In our case, these are all common results of GPL. It seems that it dividing the software world into two camps: Group-owned, viral GPL-type software that can only be modified by those who can join that group, and non-viral software that anyone can use who is willing to pay the price, which is often zero (as with X11-type software). Since there's an investment of effort that tie one to the camp one is working in, I'm suprised that so many (though still a very small fraction) are willing to devote themselves to the GPL camp. I would prefer to devote myself to software that I (and anyone else) can use to earn money, when necessary.
> "The ideal for a piece of software is freedom for _everyone_ to examine, change and share it."
He _underlines_ "everyone", but the FSF ideal does not include _everyone_; only those who will join their community by agreeing to license their work (as part of a "derivative" in GPL language) under the GPL. That's different only in degree to Mr. Gates' ideal in which _everyone_ works for him and therefor has the freedom to examine, change and share M$ software.)
BSD/X11-type licences license one to "use, copy, modify, distribute, and sell" the software. (Its permission to remove the license text and put it in another file doesn't change the license of the software. The license could just as well be on a 8.5x14 in your lawyer's safe.) It also allows you to join it with otherwise-licensed software (it's non-viral) and otherwise license binaries made from your modifications. BUT IT DOES NOT ALLOW YOU TO CHANGE THE LICENSE OF MODIFICATIONS (NOT GPL'S "DERIVATIONS"), despite what people have become
used to doing. This is standard copyright stuff, people. When you use my software under an X11-type license it is still my software. You may modify copies of it and it still contains my work which I own. The fact that the modified work contains work by both of us only means we share ownership. Nothing has given you the right to change the terms of my license. If you could legally change ANY term, you could similarly change ALL of the terms, including the one that requires maintenance of the copyright statement.
Sheesh.
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.
---
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.
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.
The fact is the world we live in is hostile to exchange of information. They say things like "It's your life's work why should you share it?" Or "You are elite, no one else deserves it." Or my least favorite, "I would be offended if someone changed my code." That's about as scary as the psychological ties some people form with Tamagotchi pets. Of course the worst is the pet rock movement. Juvenile.
Information is fluid and material just like everything else. It is easily copied but thanks to the fact that people are afraid of books, a group of 200 people will have a harder time with a document than a group of 5.
Frankly, I would be happy if someone decided to change my code put it to their own use. It would not change my source. I know what I wrote. I don't have an ego void to fill. In fact sometimes the modifications can be a form of communication.
In the world we live in, you either hide information or make it available. As long as NSI and the threat of software patents exists I will continue to use the GPL. If they did not exist, the GPL and BSD not be needed.
I know why the BSD folks like their license. I understand. However, their approach is equivalent to putting up a site on the web and calling that publishing. Hello, you forgot the fact that most people buy into the idea that they are worthless and helpless and should have to depend on IBM,MS,AOL,Apple,SUN,etc.
Publicity is important so that people have a complete picture of the world.
Think about it the one who talks to the customer is the one gets to tell the story first.
As for your binary only distros, look at the distros every once in awhile. They're all binary only. They simply include the source for the kernel because it's not the distributors' business to decide what the buyer can do.
The ship sank. Get over it. (This sig was cut out from another's shirt and painstakingly hand-posted)
The BSD license didn't protect BSD from harm. BSD is and has always been on the same growth curve as Linux. Just afterward it was set back two years.
I'd love to find the article for you. LinuxMall.com has it.
As for political platforms. Please look around. If IBM had open sourced their BIOS originally Phoenix wouldn't have had to go to court to protect their reverse engineered clean room BIOS.
The GPL is not about politics. It has the same purpose as the EULA. To control opportunity.
EULA controls to stifle opportunity. GPL controls to open it. Comrade Gates stifles opportunity.
Only the BSD needs court action. The GPL never goes to court.
The ship sank. Get over it. (This sig was cut out from another's shirt and painstakingly hand-posted)
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 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?