Follow Slashdot blog updates by subscribing to our blog RSS feed

 


Forgot your password?
Close
typodupeerror
×
GNU is Not Unix

Ask Slashdot: GPLed code with non-GPLed output 263

Posted by Cliff from the working-with-viral-licenses dept.
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?
This discussion has been archived. No new comments can be posted.

GPLed code with non-GPLed output More

GPLed code with non-GPLed output

Comments Filter:

  • Word Processors (Score:1)

    by Anonymous Coward
    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.


  • This viral stuff is backwards. I think the BSD license is actually more viral than the GPL. Here's why:
    [...snip...]

    This is rhetorics. In reality:

    • If you use BSD drivers in Linux, they are released under the GPL.
    • If you use Linux drivers in the FreeBSD kernel, you must distribute your version of FreeBSD under the GPL.

    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.

  • GNU Autoconf (Score:2)

    by Anonymous Coward
    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.

  • "Code" just means fragments (Score:2)

    by Anonymous Coward
    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

    //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();
    //BEGIN LGPL Code
    SomeLGPLFunc();
    //END LGPL Code
    return 0;
    }

    Sean Upton
    sean@sltrib.com

    Why Not? Any thoughts?

  • Re:Depends on what your program does. (Score:2)

    by Anonymous Coward
    I would recommend that SOMEBODY consult with a lawyer, someday. The grandstanding around these topics gets ridiculous sometimes.
  • The GNU Bison program:

    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.

  • No. That's bullshit. Please stop lying.
  • Yes you do. BSD licensed code still often has multiple copyright holders.

    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.

  • Hi.

    If the GPL isn't valid, then that does not mean that GPLed code is public domain.

    Instead, it means everyone who has taken advantage of the rights the GPL gives them (as opposed to copyright law, which gives users almost rights), could serve time in prison.

  • 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.
  • The GPL is indeed self-explantory. Its point, however, is to infect as much software as possible with the GPL virus (a.k.a. GPV), and to advance the political agenda of RMS and the FSF.

    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.

    ---

  • In order to use GPl'd programs, just as with Microsoft programs, I must submit to an onerous license restricting my freedom.

    This is simply false. From the GPL:

    Section E.2.0: "The act of running the program is not restricted"

    Section E.2.5: "You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Program or its derivative works. These actions are prohibited by law if you do not accept this License. Therefore, by modifying or distributing the Program (or any work based on the Program), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Program or works based on it."

    As you can see above, you must accept the GPL _only if_ you wish to _modify_ or _redistribute_ the program.

    ---

  • 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.

    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.

    ---

  • Ahh, yes, the old "BSD vs. GPL" flame war... As meaningless as ever...

    While you hit on the best position (IMHO) to hold on this issue, I think you are missing some of the subthemes of the flamewar... That of the GPL "not being free", and that of the people who whine because they cannot do whatever they want with other peoples' code. Jeez.

    Happily, one finds people on the BSD license camp like you who don't go about whining that they should be able to take others' GPL code proprietary...

    ---

  • The GPL doesn't enslave people; it merely reduces their rights. It also claims that it's increasing people's freedom.

    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.

    ---

  • Gosh, yes, those FreeBSD folks are such greed-heads ... :-)

    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.

    ---

  • The GPL refuses the right to do silly things like make changes and distribute them in a proprietary manner.

    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.

    ---

  • If I spend years writing a program using no code other than my own, I can release it under any license I want. If I incorporate BSD licensed code into my program, I can still use any license I want, so long as I preserve copyright notices. If, however, I want to include GPLed code in my program, the GPL forces me to release my program under the GPL. It has *infected* my program. This is where the term `viral' originates with regard to the GPL.

    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.
  • Actually, we recently had this discussion (not less than a week ago) on the berlin-design mailing list reguarding CORBA compilation of IDL files into source and the linking of non-GPL compatible libraries to GPL executables.


    And then there is:

    I now understand CORBA much more than before, and my conclusion is that people who want to make proprietary programs talk with your objects have a lawful way do so, no matter what licenses you use. [progressive-comp.com]

    The license for the IDL file cannot stop this in an enforcible way. Since there is only one way to write a valid IDL description of any given protocol, people are allowed to use the same IDL description, so you cannot really enforce the copyright on it. And if one ORB does not let them use the generated library in non-free software, they can use some other ORB. I am sure there are some ORBs (perhaps proprietary, but these people won't mind that) which permit it.

    However, using the GPL on IDL files might have a substantial practical effect even if it isn't legally airtight. It might discourage much proprietary software from being written to talk to your objects, and it might convince many of the people who write programs that use your objects to make their programs free.

    And finally a little explanation of "derivative":



    --
  • Isn't this a little like asking if you can use a GPLed compiler to create a non-GPLed program?


    ...phil

  • 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.
  • 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).
  • It is ignored by the GPL because it is entirely defined by copyright law.

    • Derived works are copyright by both the original author and the new one.
    • To do anything beyond fair use with a derived work you need the permission of both authors.
  • 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.
  • 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.
  • "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?"

    Good question. The answer is: /because proprietary software isn't slavery,/ any more than copying licenced software is theft. (It's copyright violation, not theft.)

    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.

  • You've got the verb right, but the wrong direct object.

    --

  • agree. (Score:2)

    by mattdm ( 1931 )
    Sorry Bruce, but it's true. In your sentence, "effect" refers to the data owner's copyright. Which is something they obviously _do_ want effected (and unaffected). What you meant to say was maybe "You may use this program to process your own programs and data without effecting the provisions of the GPL upon those programs and data."

    --

  • 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.

  • 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.
  • 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
  • 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...
  • Ambiguity creates confusion. If you can add two sentences that eliminate ambiguity, do so, even if it might be overkill.

    Bruce

  • I've had this argument about 100 times.

    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

  • This beats arguments about the GPL any day.
  • As the copyright holder (generally the author), you get to set the initial license. If you say in that license "all derivative works must use this same license", as in the GPL, that's the way it will be. If you use the X/BSD/Apache license, you are leaving the door open for others to layer different license provisions on top of yours.

    I hope that answers the question.

    Thanks

    Bruce

  • Your metaphor is invalid. People who sell add-on parts don't make copies of my car and sell them.
  • 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.
  • If I want to include [someone else's] GPLed code in my program, the GPL forces me to release my program under the GPL.

    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

  • Re:Bison vs. Yacc (Score:4)

    by Bruce Perens ( 3872 ) <bruce@perens.com> on Monday July 12, 1999 @04:56PM (#1806341) Homepage Journal
    Actually, this was solved long ago. Bison includes a parser in its output. That parser contains this comment:

    /* As a special exception, when this file is copied by Bison into a Bison output file, you may use that output file without restriction. This special exception was added by the Free Software Foundation in version 1.24 of Bison. */

    You may do something similar for any GPL-ed program for which you are the copyright holder.

    Thanks

    Bruce

  • This viral stuff is backwards. I think the BSD license is actually more viral than the GPL. Here's why:

    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

  • Easy to solve (Score:5)

    by Bruce Perens ( 3872 ) <bruce@perens.com> on Monday July 12, 1999 @04:44PM (#1806343) Homepage Journal
    Just preface the GPL with this explicit exception: "The output of this program is not a derivative work of this program. You may use this program to process your own programs and data without it effecting your copyright rights on those programs and data."

    Thanks

    Bruce

  • or... (Score:1)

    by Mawbid ( 3993 )
    everything you encoded with l3enc would belong to Fraunhofer IIS. Now wouldn't that be fucked up? (Ok, that's a slightly different issue)
    --
  • 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.
  • Well, obviously you're partisan and you have an interest in maintaining the division, but I was trying not to be.
  • 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.
  • 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"!
  • this isn't rocket science. go look at bison's info page, see the "conditions" section.
  • The GPL doesn't enslave people; it merely reduces their rights. It also claims that it's increasing people's freedom.

    It lies.

    I believe the misunderstanding here is over whose rights are at stake. The GPL explicitly protects the freedoms of users against a distributor or modifier of GPLed code exercising a perceived freedom of his own. Thus, for some people who would want to take GPLed code and make proprietary extensions or changes to it, yes, it's limiting. However, for the users of such code, it's freedom-expanding. It trades the freedom for one person to do a specific thing (make proprietary changes that aren't GPLed) for the freedom of many people to do a bunch of specific things (have the source code to make their own changes and mods to).

    In the aggregate, it increases freedom. I do not believe that the GPL claims to "expand" an individual author's freedom with respect to an individual package that he's modified. It does claim to also help even the individual author in the same way it helps the rest of the computing public, by increasing the "aggregate" good. Thus, it does not lie, though you may disagree with whether such a goal is or is not noble.

    increases freedoms (over the standard proprietary licensing schemes)
    -- Ryan Waldron

  • The GPL doesn't enslave people; it merely reduces their rights. It also claims that it's increasing people's freedom.

    It lies.

    I believe the misunderstanding here is over whose rights are at stake. The GPL explicitly protects the freedoms of users against a distributor or modifier of GPLed code exercising a perceived freedom of his own. Thus, for some people who would want to take GPLed code and make proprietary extensions or changes to it, yes, it's limiting. However, for the users of such code, it's freedom-expanding. It trades the freedom for one person to do a specific thing (make proprietary changes that aren't GPLed) for the freedom of many people to do a bunch of specific things (have the source code to make their own changes and mods to).

    In the aggregate, it increases freedom. I do not believe that the GPL claims to "expand" an individual author's freedom with respect to an individual package that he's modified. It does claim to also help even the individual author in the same way it helps the rest of the computing public, by increasing the "aggregate" good. Thus, it does not lie, though you may disagree with whether such a goal is or is not noble.


    -- Ryan Waldron

  • Re:Use of appropriate licenses (Score:3)

    by Swampfox ( 5285 ) on Monday July 12, 1999 @05:48PM (#1806353) Homepage
    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.

    As a slogan, this is catchy, but the problem is, the GPL does not enslave anyone. No one has to use it. The FSF/GPL project (personifying for a moment) is a merchant. It offers its goods (really cool software, source included) for a price: philosophical agreement on projects you derive from it.

    That's not enslaving, because you have a *choice* whether to derive works from it. It may be seductive, enticing, tempting, annoying, exasperating, etc., but it's not enslaving.

    -- Ryan Waldron
  • Lead in comments like the following:

    redhog asks this question dealing with the viral nature of the GPL
    really should be avoided, as the use of the term "viral" is an obvious put down of the GPL and its adherents. Surely you can come up with a better term to describe the benign nature of the GPL.

  • Actually, the case for a compiler is just a very particular case of metaprogramming. Now, consider what happens if someone would use more elaborate programs, that do code transformation based on semantic analysis and uses huge incrementally developed knowledge bases. And consider what happens if the knowledge base uses dynamic feedback from the programs on which it is run (as with experience-based learning). These are issues I discussed (among other things) in my paper Metaprogramming and Free Availability of Sources [tunes.org]. The notion of metaprogramming makes software licences and intellectual property completely inadequate; conversely, intellectual property makes metaprogramming very difficult, and is one great reason why AI is so little advanced today.

    -- Faré @ TUNES [tunes.org].org

  • 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.

    --

  • 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.]

  • It's up to the author (Score:3)

    by scrytch ( 9198 ) <chuck@myrealbox.com> on Monday July 12, 1999 @04:58PM (#1806361)
    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 :)
  • don't give them any ideas!
  • The GPL does contain a statement saying that it cannot be modified for other use: Quote from the Preamble of the GPL

    Everyone is permitted to copy and distribute verbatim copies
    of this license document, but changing it is not allowed.


    This means if you want a less restrictive license then you have to put the effort in and write the whole thing yourself. The text of the GPL is not copylefted.

    In this case though, the guy wants to write what is effectively a compiler. So to say that the output is GPLed means that all gcc output is GPLed too.
  • It says that also (in clause 0 it says you must include a copy of the GPL with any copy of the source code)
    What I am talking about is the fact the the text of the GPL is also a piece of intellectual property which is owned by the FSF.
    Have a read of the preamble [gnu.org]. This describes how you may use the license and it says you may not make any changes to it. You will also notice their copyright notice at the top of the page.
  • Fair enough but I think it would be quite tricky to specify the changes correctly as the GPL is quite complex and self-referential.

    If I was RMS I would specifically prohibit distribution of the GPL with software which is not licensed under the GPL (or maybe something subtler than that). That way anyone who decided to make a license which subverts the GPL would not be allowed include a copy of the GPL with their software and therefore would not be able to include a full copy of the license agreement!
  • Affect can be a noun.

    A person with a flat affect is someone who shows little emotion on their face, or maybe they maintain all of their facial muscles with as little tension as possible, all the time.

    The secret to using the words affect and effect is to use your dictionary and learn what the words mean. If you forget, look it up again.
  • Effect can also be a noun, but affect cannot.

    Yes it can; it's a term used in clinical psychology, roughly synonymous to "emotion." For example, "he spoke without affect" is a legitimate sentence.

    Ordinarily, I let stuff like this pass--I'm pretty much in the "if I understand what you mean, it's OK" school. Bruce was 100% right in intention, and there isn't a person here reading his words who didn't understand just what he meant. On the other hand, folks who make silly critiques look silly themselves when their criticism is wrong in its particulars...

    -Ed
  • They can use it for whatever they want. They just have to let anyone they give it to use it for whatever they want also. For them to do this, they must be provided with source.
  • Um...huh? What are you talking about with licenses...nevermind...I can sell you a key that will allow you to add 10 seats, for the low price of 10 dollars. You won't find RedHat offering deals like that!

    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? :)

  • Not that I understand why anybody would want to work on source code just so others could profit from it ...

    A company that uses GPL'ed software in place of commercial software saves money, and thus profits. There is nothing in the GPL which prevents this. "Why should we pay Sun for their Solaris C compiler when we can get GCC for free?"

  • So why haven't they stolen BSD?

    If I write a program and I want it to be free, I will release it under something like the BSD. Others are welcome to release it under whatever license they choose. I don't care if person A uses my code in a proprietary program. I don't care if person B uses shredded printouts to line the bottom of a bird cage. I'm giving my source code away while still maintaining my rights to the original. I write code because I need it. Anyone else can do whatever they want with it. I still have what I wrote.

    I do however see the benefits of GPL. I just don't think I'll ever use it unless I happen to find myself using GPL'd code.

  • 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.
    Because, for some of us, we want to give the users of our software maximum freedom.

    In some situations it's simply more convenient not to have to deal with the restrictions of the GPL. If I can help people more by keeping them out of licensing goo, I'll go that route. I write software to make the world a better place for everyone, not to push some political agenda on others.

    cjs

  • '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.
    Just out of curiousity, why wouldn't you write it? It seems to me that if you don't write it, it adds nothing to the world, but if you do write it, even if you don't force someone else's code public, you've added something to the world. Why should it be so bothersome that someone else might release a different version of your program without source when your original program is still out there with source?

    cjs

  • How about, `a damn nice thing from the point of view of software consumers'?

    As an example, I used to use a Telebit router. It had TCL built in, and thus had a far better and more powerful scripting language than it would likely have had otherwise. This made my life a lot easier. Had TCL been GPL'd or not available at all, there's little chance that Telebit would have spent the kind of effort (and money) necessary to make a scripting language that powerful for just this one purpose.

    cjs

  • so if want to use the products of our labor, you damn well better pay for them.
    I have no problem with this attitude; I just have a problem with calling such software `free.'

    cjs

  • 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.
  • It would be nice if Tom Christiansen would post with his real name. Or is this just a brilliant parody?
  • 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.

  • couldn't you just comment that some portions of the code are LGPLed and the rest is GPLed[?]

    No, you cannot. Section 1 of the GPL says this:

    If identifiable sections of that work are not derived from the Program, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Program, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it.

    When you combine GPL'd code with any other code to form a single work, the resulting work must be distributed under the terms of the GPL if it is distributed at all. (You may use the work yourself without ever revealing the source code, but you can't share or sell your work without sharing the source code.)

  • Tcl is a highly successful open source porduct which is now making money for its authors through the company they set up, Scriptics.

    "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.

    The real driving force behind the GPL flame wars (like this one) is a conflict between philosophies. On one side, we have people who cannot understand motivations other than profits. On the other, we have people who are primarily motivated by things other than profits; but these people often fail to understand that there are people for whom money is more important than anything else.

    In the middle, there are all the rest of us who try our best to explain things to both sides. :-(

  • 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?
  • From the GPL 2.0:

    "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 /usr/src/linux/COPYING file (thats the one that comes with the Linux kernel) states:

    "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.




  • What's the fine line between code and data?

    Didn't RMS indicate that code documentation would come under GPL? What about paper documentation? Where should the distinction be drawn between free software and stuff that is worth paying for?

    LL
  • You raise a few interesting questions. :)

    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.

  • 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.

  • Re:This "viral" stuff is all backwards, anyway (Score:4)

    by vulcan ( 30164 ) on Monday July 12, 1999 @06:47PM (#1806408)
    Perhaps you need to make an effort to understand the reasons people refer to the GPL as viral.

    If I spend years writing a program using no code other than my own, I can release it under any license I want. If I incorporate BSD licensed code into my program, I can still use any license I want, so long as I preserve copyright notices. If, however, I want to include GPLed code in my program, the GPL forces me to release my program under the GPL. It has *infected* my program. This is where the term `viral' originates with regard to the GPL.

    The BSD license does not affect code and cannot affect code since it can always be placed under another license. If someone makes proprietary enhancements to my BSD licensed code on his own time with his own money, the only code that has been infected with a non-free virus is his. My code is still perfectly free. I can give it to whoever I want and it is still as free as ever. The only thing I can't do is give away the other person's proprietary enhancements made with his own time and his own money and which could possibly completely overshadow the features provided by my small amount of code.

    Although the BSD license encourages the reuse of code for *any* reason, including in projects released under non-free licenses like the GPL or one of the dozens of proprietary software licenses, doing it to piss people off will not get you very far, and it will make you look foolhardy, especially in the eyes of the people who wrote the free software (free for *any* purpose) that you would be making non-free. I guess you think no one understands the BSD license.

    All in all, a fine spirit to take in the name of free software....


    sc
  • 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"..
  • I suppose we could be clever and make the binding between application and interpreter looser (say, consider spawning an interpreter task to which one pipes commands, and from which one reads output)
    Funny you should mention that. I just posted a freed version [perl.com] of readline(). OK, it's not totally free, but I freed what I could; it's still LGPL'd. But at least the grim spectre of GPL'd libraries instead of simply LGPL'd ones has been put to rest.
  • As many have pointed out, separation of components is the way to win at this game. You can place the clean parts in a separate file, which is a good idea anyway, since data-driven programs are much more flexible.

    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 [perl.com] of getline().

    Then again, was there some reason you had to use the GPL?

  • 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 do from your writings consider you a reasonable man. I believe that reasonable men can differ here as in many places. It is possible that you and I will be such.

    I wrote it for the same reason as I perceive Richard to have written the GPL: I wanted there to be more free software in the world. Is that really so bad? Was Richard spiteful of commercial interests when he freed previously non-free code? Are we really that far apart?

    I happen to believe that having the GPL on libraries is wrong because it harms innocent people -- that libraries should at most never be more than LGPL'd. It makes no sense to me that a script that calls a GPL'd program is not itself GPL'd, but that a program that calls a GPL'd library is. This seems a false distinction. What if the script got compiled into C code someday, and things like basename were inlined? Would it suddenly become tainted?

    I have therefore provided through my functioning prototype an insight so that any who care enough about the matter for a particular library function can free that function from the GPL so that it is only under the LGPL and therefore useful once again.

    My stated position is that it's time for the FSF to issue all libraries under the LGPL alone. I have since been apprised of certain unpleasantries regarding that licence which may themselves prove problematic.

    But at least simple use of readline() is free at last.

    I enclose here my release announcement:

    GPL'd libraries infect code that links against them, but LGPL'd libraries do not. The FSF is trying to back off from the LGPL because it is non-viral, and the virus serves their nefarious purposes to restrict people's freedom. The GPL applied to libraries interferes with honest people trying to do honest work, e.g. you can't use both GNU readline and proprietary libraries from Oracle (or Sun or Microsoft, etc) in the same program with the GPL, but you can with the LGPL.

    The FSF's published position is that if there exists *only* a GPL version of a particular library function, then a program that uses that function's API is infected with the GPL. But if there exists both a GPL *and* a non-GPL version of that function, then a program that uses the function's API is *not* infected, even if it should be linked against the GPL library.

    This strange-action-at-a-distance policy, in which the incidence of infection rests upon unknown and perhaps unknowable acts of a third party who wrote neither the program nor the library, would appear fundamentally unsound, because it means that the actual contamination is indeterminable. Yet being that their position, it is also their downfall.

    What I've done is demonstrated how you can isolate GPL'd library code in a separate *program*. You then write a function with the same API that access the contaminated code in the external *program*. Programs do not infect either their callers or their callees, so your function is now safe. After all, programs that invoke emacs are not contaminated, nor are programs which emacs invokes.

    More importantly, the mere *existence* of this "condomized" function means that anyone may now link directly with the GPL'd version without becoming infected with its virus.

    And thus by this simple idea can all GPL'd libraries be freed from their vexing bonds of servitude and insidious infection, becoming instead LGPL'd ones available for unobstructed linking by anyone for anything, thereby making the world a better place.

    I encourage all to look through the code. This is the same thing as BSD's bc program does -- it's a program wrapper.
  • 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.
  • 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?

Slashdot Top Deals

"Here's something to think about: How come you never see a headline like `Psychic Wins Lottery.'" -- Comedian Jay Leno

Close