Slashdot Mirror
GPLv2 Libraries — Is There a Point?
PiSkyHi writes "I understand that if I build an application that links with a library that is licensed under GPLv2, I must also make my application GPL2. I can see that value in this for an application. But for a library, what's to stop me separating my program into a GPLv2-compliant client app that talks to the rest of my (choose my own license) application?"
I think a reasonable test would be to ask: is my program still mostly useful even if the GPLd helper/plugin is removed (modulo the specific removed function)?. If so, then I think it could be argued that your program is NOT a derivative work and that the GPL helper is governed the same as, say, a GPLd user application bundled with a commercial Unix/OSX distro. Personally I don't think it should matter how exactly it communicates with your code - what makes launching a process any different from a function call here?
Conversely: artificially doing contortions with your software to move essential libraries out to a separate app is not only in bad faith, but it doesn't work around the license at all. And if you ever had to argue otherwise, anyone turning up your slashdot story would not probably work in your favor.
IMHO the GPL, even v3, needs some work to clarify this question and also to close the hole for the software-as-a-service industry to modify GPL code without reciprocating.
what's to stop me separating my program into a GPLv2-compliant client app that talks to the rest of my (choose my own license) application?
Umm... nothing?
If you're writing your application from scratch without using anybody else's libraries, you're free to release it under whatever license you like, even if it happens to talk to a GPL'd client plugin thingie, and even if you wrote that GPL'd client plugin thingie around somebody else's GPL'd library.
Why do you imagine that somehow there's a problem here?
$x='S24;r)>63/* h@<5+oZ)32"5cz';$me='phroggy'x$];
$x=~y+ -xz+\0-Tx+;print$_^chop$me for split'',$x;
The point is that enhancements to the library stay LGPL. I did this myself. I needed to modify LGPL libraries for the purposes of my application. I modified the libraries, and I am redistributing them under the LGPL. My main application is distributed under BSD license, and uses the LGPL libraries. The libraries make perfect sense separately (and in fact, I have people using them for reasons unrelated to the application I built). I think that, out of courtesy, and probably out of need, you need to make sure that the libraries are available separately.
This is exactly why the LGPL was created. Or sometimes you will have a GPL lib with the linking or classpath exception. You will find most libs are licensed under these, or even more permissive terms.
Therefore, if the lib in question is explicitly licensed under normal GPL, it's the author's wish that any apps that use it must be GPL compatible. I think it's only fair to follow the author's wish.
Doesn't the license basically stipulate that you must release your code under the terms of the license? That doesn't necessarily mean you have license your code as GPL.
This is actually a common FUD discussion that occurs between developers who use MIT/BSD license for their code, and are afraid to link to GPL libraries because it might force them to release their code as GPL. I'm pretty certain that as long as their code is available under the same terms as GPL code, they can license their code however they wish otherwise. It just means if a GPL nut comes a knockin', they'll have to provide the code as if it was GPL'd.
Correct me if I'm wrong (and I often am).
There is nothing wrong with you not using my code if you do not like my conditions, either...
This summary is posted under "News" but there isn't any news in the summary nor is there a link to any news. WTF?
With commingling, it will be hard for GPL zealots to discover that you are indeed violating the GPL but once they do (I do not know how they do it), just release everything and beg for forgiveness. By that time, you'll already have made your profit.
But remember: You'll not be able to put a price on the publicity all the "fracas" will generate.
I understand that if I build an application that links with a library that is licensed under GPLv2, I must also make my application GPL2
That is NOT correct.
The criteria is 'derivative work', not 'link to'. Linking is sometimes a rule of thumb in this area, but it isn't decisive.
Note that 'derivative work' is a legal term, not a technical one. So before you try to circumvent the GPL in this way, consult a lawyer.
http://clisp.cvs.sourceforge.net/*checkout*/clisp/clisp/doc/Why-CLISP-is-under-GPL
It's not a direct link, but nonetheless you should strive for independence of that functionality. Otherwise you are trying to comply with the letter of the law, but it may not be enough.
Quite aside from the legal meaning of the GPL, you could always ask the authors what they intended. If they want to prevent proprietary applications from using the library, as promoted by , that should influence your decision.
IMO, if the internals of your application are dictated by a GPL'd library -- *regardless* of how that library is linked, integrated, called, or plugged in -- your application is a derivative work. To separate them, put the library aside. Do a proper design. Gather scenarios you need the plugin to support. Document them. Write a new API. Document it. Collect some alternative libraries. Verify that you were not unduly influenced by the GPL'd one.
Or, you know, GPL the application.
Pardon, fumbled the link.
Why you shouldn't use the Lesser GPL for your next library
The problem is that there are plenty of zealots that will tell you that incorporating any GPL-licensed component in any way immediately forces the entire body of work to be released under GPL.
This can be interpreted at various times to include static linking, dynamic linking, linkage via any sort of invocation such as exec, RPC, and any other sort of connection between two pieces of code. What is the "right" answer? It isn't all that clear. It can be a matter of intent or of benefit. If the developer is benefiting from GPL code, then their project should be under GPL.
Further, what any competent lawyer will say is the objective is to avoid lawsuits. This means taking a proactive position to avoid getting into situations where some GPL zealot can potentially sue.
Essentially trying to play games with GPL can bring you into conflict with zealots. Some of these people have resources which allows them to file silly lawsuits without personally costing them a fortune. These are people to avoid coming into conflict with. So take the broadest possible interpretation of the GPL and live with it.
What you just described is not a problem. It reminds me of Samba. Microsoft never released a GPL'd SMB client. But others did hard work to reverse engineer it because the idea of not knowing how to log in an access files and print to windows servers, and pay for the license was abhorrent. This was their own data and equipment. (Remember that if the proprietary windows OS and smb client that came with it were the only way to log in, you paid twice... once for the OS and the "free" client, and once for each user or device that connected to the server.)
They could have released an open source client, or not kept the client protocol secret, or even made the proprietary client free per user and only charged users based on the number of concurrent connections to the file/print server. But they didn't. That's why it was reverse engineered. And further, now the samba project has expanded to emulate the server itself.
If you're considering making a closed server but open client, and the product actually becomes popular, you should expect that someone will make an emulator for the basic server functions eventually.
But I'm guessing the reason you want to use GPL'd software for the client is that it will help you develop your app better. And I'd also assume that after you think about the server-based per-user licensing model, you'll want to make the server more complex to deal with it. And when you make the server more complex, you'll look to see the best way to solve the problems you face, and you'll desire to use some open source library in the server too.
A lot of software users don't really care about such legalities.
In a world where there are millions of copies of bootleg Microsoft products and MacOS is coerced into running on non-Apple hardware, do you really think they will care about the subtleties of the various open source licenses?
Realistically, what are the odds you will do something that anyone will notice?
You can't make a linked wrapper library since the GPL wrapper would be GPL too. See: http://www.gnu.org/licenses/old-licenses/gpl-2.0-faq.html#GPLWrapper However it sounds like you are talking about a service based wrapper. Then I'd say it depends on how integrated your service wrapper is with your main program. If you use separate processes but lots of IPC and shared memory then I'd think you app is to tightly integrated making it a derived work. If you make a network based service then I'd say you are legally clear even if you'll probably piss off the library author. See: http://www.gnu.org/licenses/old-licenses/gpl-2.0-faq.html#NFUseGPLPlugins You could also make your app GPL but put a lot of the functionality in non-free plugs, see: http://www.gnu.org/licenses/old-licenses/gpl-2.0-faq.html#FSWithNFLibs Of course you could also just release you app as GPL and not worry about it. What is stopping you from using the GPL?
My Hello World is 512 bytes. But it's also a valid Fat12 boot sector, Fat12 file reader, and Pmode routine.
Not only is the GPL not specific on this issue, but it is unclear whether a clear license restriction on linking would even apply. Imagine if RMS and Linus had their way, and the author of an application could not only restrict distribution, but linking as well. Microsoft could legally prevent people from writing apps and drivers for their OS. Homebrew for restricted systems would actually be illegal. Would it be legal to write compatible libraries?
The great thing about shared libraries is, you don't have to distribute them, and therefore are not bound (AIUT) by their distribution licenses.
Reasonable demand, but I think the original question was along the lines of not completely understanding "your" intent...
Fine, but then don't pretend your code is "free."
You obviously don't know much about Linus to include he and RMS on the same side of a licensing issue.
There is nothing wrong with you not using my code if you do not like my conditions, either...
So much for being open and free.
I tend to find myself in agreement with the OP. More and more it seems like the GPL is not a license designed to promote free and open source software but instead comes across as a "I'll scratch your back but then you are legally obligated to scratch mine" contract. I realize this probably stems from an irrational fear of proprietary software -- fear that F/OSS code will get eaten up and essentially stolen if there wasn't the backing of the GPL. That combined with the attitude of "for-profit companies shouldn't get something for nothing" isn't very endearing and it's no surprise Microsoft can sell the idea that "the GPL is a virus". The truth is that they really aren't hitting too far from the mark, except, perhaps, with respect to intent. I do think the GPL authors mean well and lack the malice that Microsoft seems to be suggesting exists.
It seems like anyone that really values and supports F/OSS would prefer LGPL or BSD style licenses. Allowing derivative works to remain closed source isn't a detriment to the open components and it really does look better to closed source companies. This should lead to more people adopting and using F/OSS, both open and otherwise. That's good, isn't it?
"What do you despise? By this are you truly known." --Princess Irulan, Manual of Muad'Dib
/)
but it is free...free from abuse by those who want to take and not give anything back.
'Free' is not a magic word that means something absolutely, there is no $DEITY-given dictionary which provides a canonical meaning for the word. Whether I call it 'free', 'open', 'shared', 'blue' or 'pretty' is completely irrelevant: what is relevant is what users and developers are allowed to do with the code and under what conditions.
This silly bickering about what kind 'free' is freer was boring already decades ago...
I realize this probably stems from an irrational fear of proprietary software -- fear that F/OSS code will get eaten up and essentially stolen if there wasn't the backing of the GPL.
What's irrational about that?
"When I first heard Daydream Nation it quite frankly scared the living shit out of me." -- Matthew Stearns
The whole idea of "linking" is too specific to a technology or architecture. It assumes that some code is "compiled" into some form of library and the functions become available through a "linking" process during the build.
What if I call functions in my library over SOAP? The application is still "linked" to a service ("library"), but using that logic a web browser would have to be GPLed if you access any GPLed web server.
RMS and others, (The community) possibly are there to stop you.
Probably some people have some creative interpretations of what it means to link against a GPL library, also. To call such things at least a gray area if not outright violations.
If/when they find out, they might point to your software as an example of bad practice, or put you in the "GPL Violations hall of shame", or some such.
This is especially interesting with respect to scripting languages... If I write a PHP script that utilizes mysql_* function calls of PHP, which can only be invoked when PHP has been linked against the Mysql Client library....
Is my PHP script essentially linked against the GPL'ed mysqlclient library, and therefore, (if I distribute my PHP script commercially without source) a GPL violation?
What's your definition of "use" here?
Say there is a nice GPLv2 library i know is distributed with every Linux distribution, something small. I write a closed source app that dynamically links to this GPLv2 library at runtime and calls a few functions from it. Who is violating the GPLv2 here? The developer? They haven't actually distributed the GPLv2 code, how can they be bound by its terms?
Is it the user? The GPLv2 explicitly says that the end user does not need to agree to the license at all just to run the program, so how can THEY be bound by it either?
Isn't this what NVIDIA does with it's kernel drivers? I'm surprised no one has mentioned this yet... Rob.
Oh - but the code is free - everybody can use it and do with it whatever he/she/it wants.
You are -however- not free to steal the code and sell as your own product, and so making money using someone else its work.
You are free to link to open code and keep your product close. Nothing wrong with that. You only have to publish the parts that are changed in the open code to link to your product.
Example: NVIDIA can write closed source drivers and incorporate them in the Linux kernel as module, without making anything open. Nothing wrong with that.
What IS wrong is stealing code and sell them as your own product - as I said before....
I don't really see what's wrong with that. Isn't the normal way economic transactions work in a market economy with copyright laws something like: if you want to use use a part of my copyrighted work in your own, you have to get a license from me, usually involving payment?
I see using the GPL as sticking with that as the default, but making a special exception that if you give blanket permission to the general public to use and distribute your own code, royalty-free, in both original and modified versions, then you may use my code royalty-free under the same terms. But if you want to stick to the normal copyright model, then I will also, and we can agree on terms in the usual manner.
Basically I don't see how someone who uses the normal approach to copyright licensing in their own products could possibly object to me asking them to negotiate a license in order to use my code as part of their product.
10 PRINT CHR$(205.5+RND(1)); : GOTO 10
RMS and Linus disagree on a lot of things. That does not mean that they disagree on everything. Specifically, they both agree on what I said above.
You should do some actual research before spoiting your "I know something therefore I know everything." Linus often says that Linux drivers must be GPL. RMS (and the FSF FAQ) says that only GPL applications are allowed to link against GPL libraries.
It seems like anyone that really values and supports F/OSS would prefer LGPL or BSD style licenses. Allowing derivative works to remain closed source isn't a detriment to the open components and it really does look better to closed source companies. This should lead to more people adopting and using F/OSS, both open and otherwise. That's good, isn't it?
In theory, yes. In practice, however, it seems volunteers and companies contribute a lot more to GPL'ed projects than to BSD'ed ones, otherwise we'd be arguing for the "Year of FreeBSD on the Desktop" instead of Linux.
Personally, I like the idea of a BSD kernel with LGPL libraries and GPL applications, it seems to me as the best balance between freedom and widespread usage I can see. However, if devs believe otherwise and GPL everything I have no problem with it, the market will decide which option is better and, so far, it seems they're right.
No problem is insoluble in all conceivable circumstances.
There is nothing wrong with you not using my code if you do not like my conditions, either...
Use GPL for Free Software. If you want to give us Code With Conditions, I recommend the MS-PL.
Linux Eats Trapp Sandwich Rowlfing Every Maiden As Kake Everyone. This Hat Is Stopping Gears Right Ere' Anyone Try?
Here are some cherry-picked Linus quotes about the FSF, RMS and the GPL, pulled from here.
Disagreement and thinking that the FSF is controlling and putting its fingers where they don't belong is _not_ misunderstanding. It's just not "blind and unquestioning obedience".
Their additions - whether they be "modules" or just the UI - do not, necessarily, fall under the GPL. (Yes, there have been discussions about whether a kernel module is a derived work, but most of the time those discussions ended "Legally they aren't, even though I feel they should be")
If you want to use GPL for a library.. take a look at the LGPL...
You are correct. The answer is no. If the LGPLed library dynamically calls the GPLed library, then it is the FSF's position that the LGPLed library is a derivative of the GPLed library, and thus the work as a whole may only be distributed under the GPL. Please see this section of the FAQ:http://www.gnu.org/licenses/gpl-faq.html#GPLWrapper.
For your specific requirements, I'd advise touching base with them - they have an advice service for these types of questions.
The whole *point* of the GPL is to impose the GPL on everybody. Some people seem to think that this is exactly what being "open" is all about. Rather sad, isn't it.
s/people/wankers/
Actually, you wouldn't have to make your program GPL2, you would only have to make it compatible with GPL2. Which usually means GPL2 or something even more liberal like BSD. And only then of course, if you distribute.
Try actually reading the GPL license instead of making things up.
Too many people just quote hearsay and *think* that they know the GPL, and they're wrong. You're one.
Reading RMS's comments isn't enough either. You actually have to read the goddamn license, not just repeat hearsay, regardless of source. Much of what RMS says is just wishful thinking, and is not what Eben Moglen actually wrote into the license.
The fact that it can't happen. If you BSD license project A, and company M takes it and makes closed source project B with it, project A is *still* available from your site for free and open. Your code has not been magically closed, the only thing that is closed is *their* code which they used to make their project different from yours.
If that's not very much, well, they've not got very much to sell then, have they.
IANAL, but I wrote on copyright law for my discertation.
I believe the issue is not whether any inclusion of GPLv2 code forces you to make your code GPLv2, but rather that you cannot distribute the GPLv2 code with your (separate licensed) code (closed source?). You CAN however, NOT DISTRIBUTE THE GPLv2 code. You can release your code under any license you want, and distribute it any way you want. However, you will be forced to require a separate download & install on each computer that needs the library, of said GPLv2 library. You can build a simple downloader & installer for all the separate OSS libraries that runs when your software installer runs. This way, you are not distributing the GPLv2 code as part of your code, and there is no conflict.
I am a complete supporter of open-source mind-you, and hope you don't leech, but also contribute back to the project some patches and such.
As I see it, the point of OSS development isn't to force everyone to make their code OSS whether they like it or not, rather, it is to open-up code to many more testers and debugers than you could with closed source projects. You will always end up with a better quality software in OSS projects than in closed source. I feel that is enough for me. If you wish to produce a lesser quality software, I am happy that you do. Fore, once you create the market, I am happy to become an open-source competitor and take all your clients from you with better quality software. Infact, I ENCOURAGE YOU TO DO SO >:-D
IANAL
I don't really see what's wrong with that. Isn't the normal way economic transactions work in a market economy with copyright laws something like: if you want to use use a part of my copyrighted work in your own, you have to get a license from me, usually involving payment?
Correct, but the point of being open is to not follow the norm, and to let everyone use it for the greater good instead.
I see using the GPL as sticking with that as the default
Right, so we agree, the GPL isn't an open license. Good.
Basically I don't see how someone who uses the normal approach to copyright licensing in their own products could possibly object to me asking them to negotiate a license in order to use my code as part of their product.
Entirely true, but remember, you were meant to be being "open" by using the GPL. This doesn't sound very open to me.
So I write a program licensed under the GPL, then someone else comes along and forks it, and makes it MIT/GPL. It is still mostly my work. Then Big Corporation comes along and takes the MIT licensed library, and creates a closed sourced, proprietary application from it.
I don't know if you are wrong or not, but I hope you are. That would be a serious loophole if it were true.
Perhaps you should do some research before making assumptions. There is a huge difference between pragmatism and ideology. Learn it.
In theory, yes. In practice, however, it seems volunteers and companies contribute a lot more to GPL'ed projects than to BSD'ed ones, otherwise we'd be arguing for the "Year of FreeBSD on the Desktop" instead of Linux.
Really? Every company I've ever worked at has used and contributed to BSD and LGPL projects, but not touched GPL with a barge pole.
Personally, I like the idea of a BSD kernel with LGPL libraries and GPL applications, it seems to me as the best balance between freedom and widespread usage I can see. However, if devs believe otherwise and GPL everything I have no problem with it, the market will decide which option is better and, so far, it seems they're right.
Really? The one with the closed kernel (Windows) has the biggest share, the one with the BSD'd kernel (Mac OS) has the second biggest, and the one with the GPL'd kernel (Linux) has about 1%. Doesn't sound like they're right to me.
This reminds me of our experience with mysql.. they changed the license of their drivers (the jdbc driver, in this instance) to GPL from LGPL a while ago, and also affirmed a legal position (at least in their marketing materials) that using the now GPL library would require any application dynamically linking/loading it to also be GPL, with the exception of being able to buy licenses to a separate non-GPL'd commercial instantiation of the library. (They also conveniently hired the guy who had been maintaining the previously freely useable LGPL version).
.war archive that was trivial to install (just copy it into tomcat/webapps or whatever (well, and run the database creation script to set up the tables for it) and it was good to go. After the license change he was unable to distribute a fully packaged pre-working .war file with the necessary drivers for client databases. (Oracle was propriatary, but free to distribute).. he had to write a specialized install script that the customer could use to unpack the .war, install the mysql jdbc driver, and repackage it, where the script required the client to affirm that they were using a legally licensed non-GPL version of the jdbc driver from mysql to be able to install/link it. This took the liability off of him ...The liability for having the temerity to want to talk with a basic software infrastructure service (such as a sql server), without GPL'ing his little niche app.
In theory, of course, someone else could re-invent the wheel and create another fully LGPL JDBC driver for mysql.. (I was ever-so-mildly tempted to do start work on that myself, out of spite and irritation, but didn't have the time).
Needless to say, after talking to the lawyer we had to switch our entire infrastructure over to postgresql. On the bright side, I found that I rather preferred postgres as a more comprehensive and functional sql anyway. (No more having to do manual tricks for multi-merges, etc). Still, it seemed like very bad faith to switch the license like that right out from under people who had already been using it, all in the hopes of further monetizing mysql. (Yes, the earlier license applied to the old versions of the driver... which happened not to work properly with newer versions of mysql).
I once talked to someone else else who makes a a bit of money on the side selling some piece of booking software. Unfortunately for him, almost half his clients were deploying his software in mysql shops. His software was a drop-in
I'm all for the GPL. I love it! I've used it myself in a few things I've developed. I love all the good it's brought, etc, the idea of openness, a publishing and peer-reviewed manner of developing code, all that.
But I still find it very obnoxious to make a piece of library glue GPL. That's exactly what the LGPL is there for. Logically, it's not a derivative work of mysql if you use it for processing sql transactions (making no modifications or redistributions of it of any kind) any more than a file you create in the gimp is a derivative work of the gimp.
---
the pen is mightier than the sword, the sword is mightier than the court, the court is mightier than the pen.
Exactly. The reason for the GPL is not to "protect" code or keep code free. Code will be free forever under any open source license. Big Bad Corporation can't take your code and lock it up so nobody else can use it; it's still free! The only reason for the GPL is to "stick it" to corporations and anyone else to whom it isn't convenient to fully comply with all the strings (restrictions) attached to and imposed by the GPL. In my opinion, GPL code is counter-productive because of the complexity and ambiguity of the license itself, as well as the incompatibilities that come along with a "viral" license. Case in point: How stupid is it that ZFS can't be incorporated into the Linux kernel, not because of any technical reason, but because two "free" license aren't compatible with each other. Seriously? That doesn't sound like freedom to me.
This author takes full ownership and responsibility for the unpopular opinions outlined above.
Windows is only developed by Microsoft, and Darwin if it has somebody other than Apple contributing code, I've never heard of him. Regardless, both are irrelevant, my comment was clearly aimed at the Free OS market, otherwise we could argue that since most of humanity doesn't own a computer, neither should we and so we must throw them out of the window.
And in the Free OS market, Linux is far, *far* bigger than all the BSDs combined. Explain that however you want to, but it does lead one to think that your previous employers' experiences were far from typical.
No problem is insoluble in all conceivable circumstances.
Perhaps you should pay attention. Your dribble has absolutely nothing to do with the topic at hand.
Who "meant" that? The reason I'd use the GPL isn't for some generic notion of openness, but more specifically as a way of allowing multiple copyright/reuse models to exist in a mutually agreed fashion. If you agree to license your code under the GPL, you can have mine under the GPL too. If you prefer a standard copyright/licensing model for your own software, then fine, let's do that for mine too. I'd consider adding more options of that sort too if any seemed particularly compelling. What I don't see is why I should license you my code under terms that you aren't willing to reciprocate.
10 PRINT CHR$(205.5+RND(1)); : GOTO 10
Unless the company then patents some aspect of your code and sues you to prevent you from publishing it.
The fact that it can't happen. If you BSD license project A, and company M takes it and makes closed source project B with it, project A is *still* available from your site for free and open. yada yada.
We've been through this a million times before. The company has now stolen the time of the guy who wrote the free code in the first place, or at least the guy may feel like that. It's also possible that they extended his file format or network protocol with proprietary parts, harming interoperability and the users of the free version by impeding the network effect.
Some developers care, some don't, some care or not depending on circumstance and goals of the software project. None of these positions is more irrational than the other.
"When I first heard Daydream Nation it quite frankly scared the living shit out of me." -- Matthew Stearns
Sure sounds like freedom to me.
It means when IBM incorporates JFS, or hires kernel-hackers, that those changes benefit every last linux user. That when Red Hat does the same, it might mean a competitor gets it too; but they're going to be forced to reveal their code, too.
BSD/LGPL only works in some cases. Linux is only popular because of the GPL.
Yes, because patents can't be easily invalidated by showing the really obvious prior art. Wait, yes they can.
That would not be the effect of invalidating the GPL. The alternative to accepting the license is that you are not allowed to redistribute the product at all. Something you would know if you were familiar with this thing called "copyright".
I too personally hope some countries will abolish copyright, but I don't see it happening anytime soon.
We've been through this a million times before. The company has now stolen the time of the guy who wrote the free code in the first place
No it hasn't. That guy was kind enough to give it away in an open way. This is the *point* of open source software, to be generous, and let everyone benefit from your work.
or at least the guy may feel like that.
Then he (a) is not an open source developer (b) should use a closed license like the GPL, and stop claiming to be open.
That's entirely fair enough then. I have nothing against people using the GPL because it's genuinely the model they want. I have something against people claiming to be open when doing so.
Ever heard of "Embrace, Extend, Extinguish"? It's not limited to Microsoft.
No problem is insoluble in all conceivable circumstances.
I've written a library which can be used fine without any GPL libraries but I wanted to add an extension that was essentially provided by an existing GPL library. So all I did is write a secondary library which links with my my original (non GPL) library and also the GPL library. I'm fairly confident all I have to do is license the second library under the GPL. It's clear my original library isn't a derived work of the GPL library (it doesn't even link with my secondary library nor the GPL library). Whilst the term "derived work" is a fairly legal term it isn't necessarily ambiguous or confusing to apply in the real world. I would think that the test "can my work operate in any form without the GPL work" is a fairly easy test to apply with regards to libraries and linking.
It's a strategic thing. To encourage wide industry adoption, one might adopt lgpl or a bsd-like license. Case in point: ogg.
If on the other hand the library is fairly unique or say, the competitors cost an arm and the assignment of an unborn child, then gpl's a good strategic decision. Case in point -- say, what library are you asking about anyway?
I personally default to lgpl for libraries.
Really? Every company I've ever worked at has used and contributed to BSD and LGPL projects, but not touched GPL with a barge pole.
Could it possibly be because you spread some FUD about the GPL in these companies? :P
No it hasn't. That guy was kind enough to give it away in an open way. This is the *point* of open source software, to be generous, and let everyone benefit from your work.
The guy might quite reasonably want to restrict use to other people who want to share code for free. Like if I run a "bring a bottle" party I am not too upset if everyone brings something, even if some drink more than they bring. I would not like it if someone went round collecting the bottles and selling them at the local market though. If you don't want to come because "it's not really a free party then that's up to you - but don't complain about me making my own rules.
In theory, yes. In practice, however, it seems volunteers and companies contribute a lot more to GPL'ed projects than to BSD'ed ones, otherwise we'd be arguing for the "Year of FreeBSD on the Desktop" instead of Linux.
That's just because we've already seen the "Year of FreeBSD on the Desktop." It's called Mac OS X.
But seriously, you'll have to provide a citation with your assertion that companies contribute more to GPL'd projects than projects of other licenses. The only major GPL projects with corporate contributions that come to my mind immediately are Linux and MySQL. On the other hand, many, many non-GPL projects with corporate contributions immediately come to mind. All Apache projects, postgresql, ffmpeg, BSD, memcached, OpenOffice.org, QT, postfix, bind, all Mozilla software, webkit, need I go on?
The sad truth is, the actual value of the GPL is a lot less than everybody thinks. It doesn't protect code from suddently becoming non-free because 1) corporations can't do that anyway, and 2) companies that do use non-GPL code tend to give back their improvements anyway, even though they are not legally obligated to do so. They may do it to keep good karma amongst developers rather than a strong believe in Free software, but who cares? What then is the value of the GPL? I propose it has negative value, considering the incompatibilities it introduces (ZFS anyone?) and the needless complexity it brings, but of course that's just my opinion.
This author takes full ownership and responsibility for the unpopular opinions outlined above.
No, it was because while the companies were entirely happy to contribute back changes to libraries they were using, they were not happy to open up their entire finished product, just because they used a GPL'd library along the way.
Well, that's entirely fair enough. He is quite within his rights to want this. What he shouldn't do is claim that it's open source, if it's really a "bring your own source".
I think that most of the replies in this story interpreted the question wrongly. I think the question was:
Is it legal to create application with GPL'd client, which does most of the work inside linked library with different license (f.e. completely proprietary library)?
This would allow me to use f.e. gnu readline in client while still keeping all the "interesting" stuff inside library with my own license...
I'm not a lawyer, but I think that this is the same situation as in compiling GPL'd code against Windows API - which again is something that is done quite a lot.
So what do you think?
"The whole *point* of the GPL is to impose the GPL on everybody."
Yes, that's what a public use copyright license does, it enforces the rules of your license on everybody who would use your work.
"Some people seem to think that this is exactly what being "open" is all about."
And you seem to disagree. Good for you. No, really, you get a genuine golf clap for that. "Open" doesn't mean "without rules".
"Rather sad, isn't it."
The only thing sadder would be trolling Slashdot pretending that anyone else should give a fuck about your anti-GPL opinions, and inserting aggreement with your asinine definitions into other peoples' mouths. Don't like the GPL? Then don't use it. Problem solved. Or is somebody actually holding a gun to your head forcing you to incorporate GPLed code into your projects?
Try not to take me more seriously than I take myself.
Linux is only popular because of the GPL.
That's a pretty stupid statement don't you think? I (and I'm sure I'm not the only one) use Linux because it WORKS and does what I want it to in the situations that I apply it to. I also use Windows 7, Windows Server, Apache, Python, Java, Opera and piles of other products under just about every license under the sun. And you know what? I don't give a rats ass about the license so long as it doesn't hinder me they can shove it under any license they want.
I may agree with what you say, but I will defend to the death your right to face the consequences of saying it.
What he was saying is that Linux is working now because of the GPL during its development.
Of course most end users don't give a rat's ass about the GPL, but it is this GPL which allowed one modification made to Linux to be used anywhere. Without it, we would have an IBM Linux, a Red Hat Linux, etc. In this case, why not stick to Unix ?
It WORKS because other people that liked (or at the very least, didn't mind) the licensing terms of the GPLv2 contributed. If linux had been under another license, it would be a very different beast from what it is today, and whether or not it worked in the same way that you like it working now is not an easy to answer question. (barring time machines/parallel dimension hopping, with those it's a fairly easy one...)
you are correct, there is no point. i've been exploiting this for years.
The developer is the only one who can be at fault here. The question is if linking against a library creates a derivative work, a right reserved by copyright law. The FSF believes it does, but who knows, maybe some court will find it does not.
The GPL does not guarantee that someone has to give you anything back. In fact, there is no reciprocation requirement at all.
I can, for example, take your GPL'd work, make some changes, then sell it to my customer. I am required, by the rules of the GPL, to give my customer the source, and they are allowed to do whatever they want, including give it to others, but if they paid $1,000,000 for it, chances are they're not going to do that. You have no right to demand the changes I made, or even a copy of the program from me.
This is a common myth around the GPL, that it enforces a reciprocation agreement. It doesn't. In fact, licenses that have such agreements are not compatible with the GPL.
If you need web hosting, you could do worse than here
They were saying that Linux got to where it is today because of the GPL license. The argument is that Red Hat, IBM, Novell, and other companies wouldn't have contributed to Linux if they weren't forced to by the GPL. Instead, they would have kept the code only in their own software offerings instead of sharing it, and Linux wouldn't have gotten as far along as it is today.
The GPL basically forces collaboration and sharing. I agree that that isn't true freedom in the truest sense, definitely, but certainly it did help get it this far, and has allowed more computer uses to be more free. However ironic that may seem, I believe that's the truth.
Now with the Internet being as developed as it is, it is much easier for collaboration to occur. In my opinion this needs to be much more fortified than it is now though, but at least things are getting there. There needs to be more marketplaces for everyone to buy into collaborative software projects. These need to be made easily available for gamers and desktop users, businesses, education systems, governments, etc etc. I.e. better bounty/support/development systems are needed IMO. Any way, the point I was making was if these systems can blossom, the GPL license won't be really needed as most everyone will understand what "collaborative software" is and the value in having that openness, so that you open things up to anyone contributing to help keep it afloat. Relying on closed commercial software is just dumb and dangerous.
Promote true freedom - support standards and interoperability.
but because two "free" license aren't compatible
That's because the GPL isn't "free". It's got strings attached to it, which means that it isn't free. The BSD license is free, and it's a shame that more projects haven't opted for it. Good BSD projects get updates even from commercial entities so that their own internal process is simplified since they no longer have to re-implement their custom code on every update of the original project they want to incorporate. The GPL just makes it too much of a hassle in most cases to warrant using it for simple things that can be re-written in house and not require the extra strings attached. And in the long run, what good did that really do? At least the GPL people can hold their heads in the sand and say see, we made the world a better place by giving the world this code and everyone can use it, well except for most companies, some hobbyists, and consultants.
I guess I see the GPL crowd as being very much like the closed source crowd, just with a slightly different set of rules, each in their own little world. The BSD crowd is making the world better.
I never could understand how dynamically linking my code that I wrote to someone elses code that they wrote could force me to do anything at all.
The question then becomes why aren't you using FreeBSD. (Hint: the answer is deeper than "It doesn't do what I want it to.)
Put identity in the browser.
I'm not going to start arguing with you because it's quite clear that you've given this some thought and made up your mind, but you might consider that people claiming to be open WRT the GPL may imply open and can never be closed.
Put identity in the browser.
the one with the BSD'd kernel (Mac OS) has the second biggest
The kernel is Darwin, not BSD.
Darwin is built around XNU, a hybrid kernel that combines the Mach 3 microkernel, various elements of BSD (including the process model, network stack, and virtual file system),[5] and an object-oriented device driver API called I/O Kit.[1]
Darwin uses the APSL, not the BSD license. The APSL is a share-alike license*, making it much closer to the GPL than to the BSD.
Further, your share estimates only cover the desktop, not servers.
* "If You Externally Deploy Your Modifications, You must make Source Code of all Your Externally Deployed Modifications either available to those to whom You have Externally Deployed Your Modifications, or publicly available."
Put identity in the browser.
Yes, but not "easily" -- unfortunately, it's still a legal process, and thus a bitch, even if the judge, jury, and patent office were all technically competent -- which they aren't.
Don't thank God, thank a doctor!
I am required, by the rules of the GPL, to give my customer the source, and they are allowed to do whatever they want, including give it to others, but if they paid $1,000,000 for it, chances are they're not going to do that.
True, but they might sell it to another would-be customer for $500,000. Which you might not be happy with.
I hereby place the above post in the public domain.
Can I make a wrapper that lets anyone in the world use your application (I bought a legal copy from you) over the Internet for free? If not, then you probably shouldn't try to wrapperize GPL libraries and use them in a proprietary application.
Because legally, I can find someplace where a click-through EULA doesn't mean squat and I'm perfectly free to run software that I own in any way that I see fit, as long as I'm not violating copyright by distributing it.
It's like saying that because you don't support the public option or single-payer system, you don't want people to get affordable health care.
There are alternative ways to achieve a good goal, without the tyrannical baggage.
Isn't that why the Affero GPL (http://en.wikipedia.org/wiki/Affero_General_Public_License) was created ?
That's because GPL code is only "free as in gratis" (you do not have to pay anything to get the source code). Whereas BSD/MIT and other alike code is free as in freedom.
This is a common myth around the GPL, that it enforces a reciprocation agreement. It doesn't.
No, but in practice, that is usually what happens in the end.
Sure sounds like freedom to me.
It means when IBM incorporates JFS, or hires kernel-hackers, that those changes benefit every last linux user.
Let me present you with an even freer license, which I've unfortunately had some problems with getting people to use software under: The sex-with-your-wife license. It means that whenever Joe Blow use the SWYWL-licensed software, *every last Linux user gets to have sex with Joe Blow's wife*! Sure sounds like freedom to me.
This was written to illustrate two points: YOu're really taking away freedom, and whenever you change the license, you change the likelihood of people using that software. This happens with the GPL, too. And it means that by licensing under the GPL, you lose contributions from companies like Whistle (first Multilink PPP in *BSD, the Netgraph stack in FreeBSD), Justin Gibbs (the entire SCSI stack in FreeBSD and the Adaptec drivers), and Oracle (supplied manpower for the rewrite of the BSD VM system, delivering a system that beat Linux for a decade and a half until the FreeBSD VM maintainer decided to support with the VM redesign for Linux 2.6). And of course my own very modest contributions as part of making an appliance a decade ago.
Because when we make proprietary stuff based on a free codebase, it makes sense to give a bunch of it back. When you deny us the ability to create proprietary derivates - we don't use your codebase, and we don't contribute to it. The extra code you get is the code that would have been written *anyway* (it has a large enough incremental value to be written for pure use value) but would have been kept proprietary for strategic advantage if it was written. That means that the strategic value must be higher than the combination of maintenance costs, morale boost for the employees, and community goodwill. Most code isn't - it's plumbing.
And for this, you give up the ability to have people invest in software for special interests. You could, for instance, have a free application that perfectly well served the seeing - but needed substantial modification to work for the blind. A commercial developer could take on that risk, and then sell the end result (with the added value that it is usable for the blind) to the blind. This would add value for the developers, and it would add value for the blind. The developers wouldn't do this out of the charity of their heart if they couldn't earn money on it - it wouldn't be possible to invest as much time. So, by GPLing in this example, you're denying the developer the freedom to make a derivative - and you're denying the blind the freedom to actually have a usable app at all.
So - you can argue for the GPL - but please keep to the truth: It is taking away freedom, significant freedom, to attempt different goals.
Doubting the existence of evolution is like doubting the existence of China: It just shows that you're uninformed.
What he was saying is that Linux is working now because of the GPL during its development.
Of course most end users don't give a rat's ass about the GPL, but it is this GPL which allowed one modification made to Linux to be used anywhere. Without it, we would have an IBM Linux, a Red Hat Linux, etc.
Actually, we do. And it doesn't matter, since it's just minor patches.
It is not at all clear whether the difference in forking behavior is due to the license or the external development velocity / source code organization. We don't have a large scale IBM BSD, a Red Hat BSD, etc - we have a few open source BSDs and Mac OS X, and IBM choose to contribute to an open source BSD (FreeBSD through Whistle) rather than create their own pure fork. Mac OS X also contribute changes back.
I'm attributing the major differences in fork behavior mostly to source code organization (BSD is a large tree containing the entire OS, "GNU/Linux" is a bunch of small trees that are aggregated to form a bunch of different operating systems which are close enough that people think of them as they were the same rather than forks.)
Doubting the existence of evolution is like doubting the existence of China: It just shows that you're uninformed.
2) companies that do use non-GPL code tend to give back their improvements anyway, even though they are not legally obligated to do so. They may do it to keep good karma amongst developers rather than a strong believe in Free software, but who cares?
A good reason why a company would want to give the improvements back is so that they don't have to responsible for porting those improvements over to newer versions of the code.
However, if devs believe otherwise and GPL everything I have no problem with it
I wish people would use licences appropriate to the language they're developing in. The GPL and LGPL contain terms which are only really well-defined in the C/C++ paradigm. Rather than make people who want to use your project wrap their brains about how the provisions on header files or linking apply to Java or Perl, use a licence which expresses your intentions clearly in the standard terms used for your language.
the "viral" nature of GPL is only the viral nature of copyright.
If your copyright system makes including a library binary into another work a derivative work of all libraries included in that work (even if it is wrapped in another library: that library itself must be derived from the components), then you cannot get past the needs of the GPL license on a library you use by wrapping it up in anything.
This isn't GPL licensing.
It's copyright.
How can this be possibly modded insightful? Isn't this the same place where every time stuff like piratebay are discussed people fall over themselves arguing that downloading music/movies is not stealing?
There is nothing lost, so how could it possibly be "stealing"?
I am required, by the rules of the GPL, to give my customer the source, and they are allowed to do whatever they want, including give it to others, but if they paid $1,000,000 for it, chances are they're not going to do that.
True, but they might sell it to another would-be customer for $500,000. Which you might not be happy with.
I think the following part of the GPL2 applies here.
You may charge a fee for the physical act of transferring a copy, and
you may at your option offer warranty protection in exchange for a fee.
Any customer who pays something like $500,000 for GPL'd software would have to be particularly dumb and I would not be surprised if the police were after the seller for fraud since $500,000 is a little bit expensive (fair trading act and such) for transferring GPL'd code although that won't stop con artists. On the other hand there are many customers who quite happily pay for service and support., after-all Redhat P/L does not charge for their GPL'd source it only charges for warranty and support which does not contravene the GPL. If you don't want to pay for Redhat code you can use CentOS however your company may still want some software support contact. At least you have a choice.
There ain't no such thing as proprietary standards only proprietary formats. Standards are by definition open.
There is nothing wrong with you not using my code if you do not like my conditions, either...
More and more it seems like the GPL is not a license designed to promote free and open source software but instead comes across as a "I'll scratch your back but then you are legally obligated to scratch mine" contract.
More and more? I don't think so, this reciprocity is why the GPL was created in the first place. It's meant to ensure that derived works of free software are added to the available body of free software, which counts as promoting free software in my view.
It only matters if you distribute your code, of course, otherwise you can do with it whatever you like.
Yes.
That is plain old copyright law.
Even if it is one function call, copyright says it is a derived work.
If you don't like that, you need to change copyright, not the license.
After all, the GPL is not the law, copyright law is the law. It is only the law that gives the GPL any validity at all.
Here is a description of the law:
http://en.wikipedia.org/wiki/Derived_work
"A derivative work pertaining to copyright law, is an expressive creation that includes major, copyright-protected elements of an original, previously created first work."
OK this means that in order for a new work to be affected by the copyright on an earlier work, the new work must actually **INCLUDE** "major copyright-protected elements of the earlier work".
So, if you statically link to a GPL library, then you include that library's code in your own work. If you dynamically link to a library, you don't include the library's code in your own work. It would seem then that the "GPL inheritance" would ONLY apply in the case of a statically linked library, according to copyright law.
Even then, there is a version of the GPL, called the LGPL, which is specifically designed to waive even that. A library licensed as LGPL allows another later work to include the library via static linking and yet **NOT** inherit the GPL requirements.
AFAIK, most open source libraries are licensed as LGPL rather than GPL for this very reason.
Other people require you to agree to a contract before looking at their program. [...] They're Dark Templars
FTFY.
More people have experienced the Year Free of BSD though.
Here's another case in point:
Being the free enthusiast that you are you develop a popular program. Say an open source word processor. It's free, and is quite popular in its niche. Now if you have created a program for yourself that fully serves your needs, you can release the code with a 2 clause BSD license.
If, however, you want to compete with other software makers, and you release the code with a BSD license, then any of your competitors is able to take parts or all of your code and use it in their products without ever releasing anything of theirs to the public. In the end, their software will always be better than yours because they build upon your work. Since their software is better, more people will be using it instead of your software, especially if the software is cheap (and your software will be of great aid to that). More users of your competitors' proprietary products will mean less testers and less possible developers for your open sourced software, which in turn means lower quality. Now how will this help spread free software?
Also take a look at the number of embedded devices and the number of super computers that run BSD (the FreeBSD kernel is released under a two-clause license, that is the highest permissiveness). Linux runs on many more embedded devices and on many more super computers, because the companies that embraced open source, are able to use the contributions of others, contribute themselves and make sure that nobody will turn their contribution against them by developing a closed source product with their code.
And about the ZFS being released under CDDL which in turn is incompatible with GPL: ever wondered how companies like Qt software were able to release Qt under a dual license and why Sun didn't? Or why Sun didn't release ZFS under a 2 clause BSD license, which is compatible with both, the CDDL and the GPL The correct answer is: Sun wanted to gain a marketing edge. It's no different than releasing the ZFS as closed source (from the marketing point of view).
Apple has "Mac vs PC", Microsoft has "Laptop Hunters", Linux has recession
When his "Freely offered" code was put into a GPL'd program he was as bad as even the WORST GPL "zealot".
Some people pick the BSD not because they like the license but that they *hate* the GPL.
If I want I can take BSD source, modify and/or add to it providing I keep the BSD license. I can then go on and license that modified code under the GPL (yes even the GPL3). It must be noted that what I have suggested is quite legal and I have not contravened the spirit of the the BSD license. Now the BSD people cry foul and call the GPL viral yet under the spirit of the BSD license I have not done any wrong in fact I have bent over backwards ensuring that the spirit of the BSD license is upheld.
It has got to the point were some BSD license supporters are now suggesting adding to the BSD license stating that their code cannot be put in GPL'd software which kind of goes against the spirit of the BSD license in the first place. If you wish to licence your code under a BSD licence don't be surprise if that code is incorporated under the GPL one day since there is nothing in the BSD license that forbids this.
There ain't no such thing as proprietary standards only proprietary formats. Standards are by definition open.
You, sir, are a dogmatic idiot.
They might. Or, they might consider the code to be critical to their business and not want their competitors to have it.
The point is, the GPL does not guarantee what many people seem to think it guarantees, particularly in the "must give changes back" situation.
If you need web hosting, you could do worse than here
The purpose of the GPL is to keep the project as a whole "free" not just the original version. It keeps derivatives from being locked away in proprietary forms.
If a company or individual doesn't want to contribute to a project that is free that way then they still have the freedom to create their own purely proprietary project.
Actually, LGPL is for shared libraries, what GPL is for hardware and proprieatary APIs. GPL doesn't require your own code to only use hardware with an open architecture or software that is not open source, thus software available under GPL is able to run in Windows and make use of different hardware. If GPL had imposed such a restriction, then it would be pretty unpopular, I imagine.
Apple has "Mac vs PC", Microsoft has "Laptop Hunters", Linux has recession
Software is worth whatever someone will pay for it. There is no fraud involved in charging whatever someone will pay.
And the GPL puts no limit on what you may charge. The section you quote above is in regard to the fee for transfering a copy of the source code (upon written request). It is not a requirement for how much you can sell the binary for (with the source).
Many businesses pay in excess of $1,000,000 for custom software.
I'm not referring ot simply filing off the serial numbers. I'm talking about investing many 1000's of man hours of development work into something that could be considered a derivitive work of a GPL'd application.
If you need web hosting, you could do worse than here
"usually". Not always. My point is simply that the original author claimed it was "free from abuse by those who want to take and not give anything back". That's simply not true.
If you need web hosting, you could do worse than here
The argument is that Red Hat, IBM, Novell, and other companies wouldn't have contributed to Linux if they weren't forced to by the GPL.
Not necessarily. Another possibility is that those companies would not contribute if the GPL did not prevent competitors from taking their contributions proprietary.
Not quite right.
Now it's right.
The GPL just makes it too much of a hassle in most cases
The GPL is not a problem at all for companies that do not distribute software.
Are you actually asking "can I circumvent the GPL on someone else's library using a wrapper"? or was the question "Why should I bother licensing my own library under the GPL, when others could circumvent it using a wrapper"?
The first of these has been pretty much answered elsewhere.
The answer to the second is to relax. If Big Evil Software Corp abuses your work this way then they're heading for a lot of bad publicity, even if you don't have (or can't afford) a legal case.
If someone gets away with this, shame on them, but what have you actually lost? Would Big Evil Software Corp have paid you (or even have heard of you) if you'd kept the code closed?
Licenses will have loopholes, and the more loopholes you try to close the more you introduce, and the more work you make for lawyers. How do you legally define the difference between a wrapper and a server so that a jury in Utah can tell the difference?
The free softwar community shouldn't fall into the trap of thinking like the RIAA and confusing "intellectual property" with real property. Violating the GPL isn't big, isn't clever but is no more "theft" than copying a movie, and the damages caused are intangible and hypothetical.
In a survey of 100 programmers, 111111 thought that duck-typing was a good idea.
They will need to clear this matter up if people want to see more commercial software on the Linux platform.
The one with the closed kernel (Windows) has the biggest share, the one with the BSD'd kernel (Mac OS) has the second biggest, and the one with the GPL'd kernel (Linux) has about 1%. Doesn't sound like they're right to me.
You are correct if you are looking at the desktop, however Linux runs on a more appliances than does MS Windows and BSD put together and where do you get 1% and 1% of what and which county? A little serious statistical research will show you that there are 10's of millions of Linux users in the world (Fedora alone accounts for well over 10 million) and that is not just the server room. Don't limit your research to just first world countries and I think you will be surprised.
There ain't no such thing as proprietary standards only proprietary formats. Standards are by definition open.
[citation needed]
Would you pay for patent invalidation litigation if $BIGCORP accuses your OSS project of patent infringement? Litigation can be very expensive.
What he shouldn't do is claim that it's open source
So now the BSD fanatics try to appropriate the term "open source" and claim that something is only open source if it falls within their (your) own definition.
If that's the case, it speaks for the GPL and against the BSD-style, as I see it. I mean, you don't expect me, as a FOSS zealot, to rejoice that we have the "Free and Open" MacOSX, do you?
Some of my favourite people are from th US; Vonnegut, Chomsky, Bill Hicks.
I have something against people claiming to be open when doing so.
That's your problem. Deal with it. You BSD fanatics do not have a monopoly on the term "open source".
The GPL is a distribution license. You *can* make a wrapper that allows anyone use a GPL application for free provided you don't distribute the GPL applcation.
Likewise unless their lawyers have been careful that's probably true of a lot of commercial licenses as well. Only licenses which restrict usage affect this kid of thing.
The GPL is a grant of license based on *copyright* law. Without a copy being made it has nothing to say.
So you're saying that the GPL hates blind people?
Except that open source != free (for whatever definition of free you care to use).
A particular open source project may match your definition of free, but that does not mean that any open source project will.
"Necessity is the plea for every infringement of human freedom. It is the argument of tyrants; it is the creed of slaves
The GPL and LGPL contain terms which are only really well-defined in the C/C++ paradigm.
Which ones?
Rather than make people who want to use your project wrap their brains about how the provisions on header files or linking apply to Java or Perl
"header files" isn't used in the GPL3 license at all. "link" only shows up twice, one of those usages is the generic meaning of the word, where they say "link or combine", the other usage is in defining the term "corresponding source", referring to code of any libraries or "dynamically linked subprograms" that explicitly make up the whole work, e.g. not system libraries, but a work that has been split up into separate components.
Note that "libraries", "subprograms", and "components" are terms that are just as applicable to Java or Perl as they are to C/C++ (or any other language), so I don't see any C/C++ specific verbiage involved in the license.
Note: I'm just trying to understand how you think the license is language-specific, or perhaps more importantly, why you think a "language-specific license" would be a good thing. After all, we've already got more software licenses than anyone can keep track of, having a license for each programming language out there too would only make a bad situation worse.
"linking" (in the general sense) is an issue for all programming languages that allow for separate "modules" to ultimately be used together in some way, whether the language is statically compiled & linked, or dynamically executed in a runtime environment (where the runtime engine effectively takes care of the "linking" for you), so this problem will exist no matter what.
In fact, the *real* problem here is not the programming language or the software license or what "linking" means, but the inherent vagueness of copyright *law*, specifically what is meant by the phrase "derivative work". That term comes from copyright law itself, not the GPL or any other software license, and any "copyright license" ultimately depends on the underlying "copyright law" for meaning and clarity. Unfortunately, copyright law doesn't actually give us either, never mind the problem of copyright law itself being different depending on where you are.
Except it isn't the "general public", it's only the people to whom you distribute the derived work. If you put the thing up on the internet for one and all, then that's the general public, but if you provide it to a select group of clients (say, the buyers of your router), you only need to distribute (and license under the GPL) the source code to those clients.
"So, by GPLing in this example, you're denying the developer the freedom to make a derivative - and you're denying the blind the freedom to actually have a usable app at all. "
Why? Why can't the app be GPL *and* paid software? The developer doesn't even have to put the code online, they just have to put it in the same CD as the binaries, and they can charge whatever they want.
Dilbert RSS feed
We really need to get away from pretending we are special and will become millionaires with our brilliant (read stupid to everyone else) idea. Lets agree that free/open software is done to benefit us all.
The company has now stolen the time of the guy who wrote the free code in the first place, or at least the guy may feel like that.
We've been through this a million times before. He should have thought about that before and choose a different license then.
"No, it was because while the companies were entirely happy to contribute back changes to libraries they were using, they were not happy to open up their entire finished product, just because they used a GPL'd library along the way."
I believe that to be a bit of FUD. http://www.vmware.com/download/eula/workstation65.html
Apparently, VMWare is a little bit smarter than any of the decision makers you have worked for. VMWare manages to sell a proprietary product which is based on GPL'd code. How do they manage? Could it be, because they are literate?
"Windows is like the faint smell of piss in a subway: it's there, and there's nothing you can do about it." - Charlie Br
and their argument hasn't yet been thrown out.
So ask yourself: is it worth screwing around with weasel-wording interpretations of the license just to avoid paying for software?
I am curious about your pattern of thinking. Why in the world would they not do that, since they know they legally can? People do that all the time with proprietary software, in which case they risk jail if caught.
Victims of 9/11: <3000. Traffic in the US: >30,000/y
OSX is far more open than Windows ever has been. The kernel and many of the non-Cocoa user apps are available under an open source license. It's mostly GUI components that are proprietary (but hell, you could always use Xorg).
it would be "use the copyright".
And why the pickyness? When you play your DVD, it's licensed not sold and restrictions on use go up. EULA are end USER license agreements and not a whiffle from you.
But you should read up on what "use the copyright" means since that would be the definition of "use". And if that definition is broader than you'd like, take it up with your congressman and have copyright law changed.
Now, I need a proof of good faith, beelsebob. What BSD project are you working on?
I'm asking because, in my time as a professional programmer, I remember very well that finding a BSD application was a treasure trove: you could steal all the code and pretend to have done the work yourself.
So, sorry for the suspicion if you actually work on BSD projects, but I have had it with (fake) BSD fanboys who want other people to write BSD code so they can freeload on.
Victims of 9/11: <3000. Traffic in the US: >30,000/y
The question then becomes why aren't you using FreeBSD. (Hint: the answer is deeper than "It doesn't do what I want it to.)
And what IS the answer then? Because it seems to work just fine for my hobby server...
(And if FreeBSD *isn't* included in GP's "piles of other products", he should give it a shot. Really!)
Are you sure the library is GPLv2 and not LGPLv2?
If a library is GPLv2 licensed, you can't do what you are talking about at all. You can't link GPL code with non GPL compatible code, library or not. You can't take a GPL library and use it in a non-GPL compatible application.
On the other hand if the library is LGPLv2 licensed, then yes, you can do exactly what you are talking about, as that is the whole point of the LGPL - to make sure that any improvement sto the library itself are shared with the community, without requiring the applications using the library to have their code opened.
he GPL does not guarantee that someone has to give you anything back. In fact, there is no reciprocation requirement at all.
Is there any license that does have a reciprocation requirement? I imagine it would be a PITA to sort out, e.g
A makes software that is modified by B then C,
do C have to make the changes available to A or just to B?
Upon receiving those changes if B decide not to use them do they have to make the changes available to A anyway?
Personally reciprocation is all I want in a license, however as GPL is so widely used it's easier to put stuff out under GPL and hope that somewhere down the chain somebody gives you your code back!
IranAir Flight 655 never forget!
What he shouldn't do is claim that it's open source
So now the BSD fanatics try to appropriate the term "open source" and claim that something is only open source if it falls within their (your) own definition.
Why not? The GPL zealots already did it with "Free." What's good for the goose...
$Big_Bad_Corporation = Microsoft
$Open_Source_License = BSD
$Code = Networking_stack
BSD and other permissive licenses do not keep the code open, GPL is the major license that does, sure others are available and GPL has its flaws (overly complex for many situations), but there reason is a reason it can't be linked to permissive licenses
IranAir Flight 655 never forget!
I can then go on and license that modified code under the GPL (yes even the GPL3). It must be noted that what I have suggested is quite legal and I have not contravened the spirit of the the BSD license. Now the BSD people cry foul...
Either you're making crap up, or you're talking about that wireless code fracas, where the ATTRIBUTION was stripped, in direct violation of the license.
Why you should use the LGPL for your next library: Because you want people to use it.
In theory, yes. In practice, however, it seems volunteers and companies contribute a lot more to GPL'ed projects than to BSD'ed ones, otherwise we'd be arguing for the "Year of FreeBSD on the Desktop" instead of Linux.
I don't know. The things most keeping me from using FreeBSD instead of Linux on the desktop are closed source, ironically (NVidia blobs and Cedega, mostly)
Personally, I like the idea of a BSD kernel with LGPL libraries and GPL applications, it seems to me as the best balance between freedom and widespread usage I can see.
I feel the same way, but in reverse. Linux kernel, BSD userland. That would be freakin' sweet.
But seriously, you'll have to provide a citation with your assertion that companies contribute more to GPL'd projects than projects of other licenses. The only major GPL projects with corporate contributions that come to my mind immediately are Linux and MySQL. On the other hand, many, many non-GPL projects with corporate contributions immediately come to mind. All Apache projects, postgresql, ffmpeg, BSD, memcached, OpenOffice.org, QT, postfix, bind, all Mozilla software, webkit, need I go on?
The majority of projects you listed here are either LGPL or GPL. FFmpeg is both LGPL and GPL (depending on which part), Qt is now GPL (or is it LGPL ?).If your point was to say that BSD like licenses have more commercial contributors, I'm afraid you're very mistaken. Oh, and what about VLC, mplayer, .... GPL of course. And what about Sun JAVA ? ;) Mozilla license while not GPL is closer in spirit to GPL than to BSD.
Lesser GPL is for inferior libraries, situations where the opensource library is inferior to widely used proprietary ones and getting contributions from proprietary users of the LGPL lib is better than sticking your head in the sand and pretending a GPL lib will catch up.
IranAir Flight 655 never forget!
LGPL v3 has the following:
GPL v3 does seem more language-neutral than I thought. I'm still not happy about "linking", though: can you provide a waterproof definition of linking in the context of Java programs? And if you can, would GNU's lawyers agree with your definition?
Note: I'm just trying to understand ... perhaps more importantly, why you think a "language-specific license" would be a good thing.
As far as I'm concerned a licence should be as short as it's possible to make it while communicating clearly what permissions it does and doesn't grant. Trying to make a licence too general results in it becoming longer and harder to understand. Using specific terms with agreed meaning is simply good communication.
After all, we've already got more software licenses than anyone can keep track of, having a license for each programming language out there too would only make a bad situation worse.
How many people need to keep track of all software licences? Distro managers, maybe. Programmers would only need to know the licences relevant to the languages they work with - and even then, maybe not. When using a project you read its licence; when creating one, you pick a licence you know, and if you don't know a suitable one you search or write one.
It is a misconception that you have to license an application under GPLv2 if you bind to a GPLv2 library. However is is VERY true that you fall under GPLv2 or higher if you DISTRIBUTE your code that binds to a GPLv2 library. In other words, binaries that use GPLv2 that are not publicly distributed do NOT have to follow GPL rules at all. You can ask RMS about that and he'll concur. In fact, he will tell you that localized customization of GPL software does not require redistribution or notification of changes to the "owner" (if I can use that term when talking about free software).
There is the "Lesser" LGPL license that does permit closed source (that is, short lived, unmaintainable and therefore, undesirable) software to be distributed without being free. Why undesirable?, because one day (believe it or not) that benevolent IP fascist company will go belly up.... and then ALL is effectively lost. Even SW under so-called escrow plans does NOT guarantee access since a company ultimately decides the fate of closed source software. Using closed source software ALWAYS puts you at risk since the software can actually disappear from the face of the planet. That may seem extreme, but I know I can give you several examples of VERY valuable pieces of software that have been lost due to IP closed source fascists who believed they would live forever.
So, how do you make money on GPL'd software? By supporting those that maintain software, you preserve software. When you send money to closed source companies, you don't guarantee ANYTHING. That company could kill their software product TOMORROW and there is nothing you can do about it. So, arguably, it's the wrong question to ask. The right question to ask is: Can YOU make money building your business on proprietary software that might not be there tomorrow?
host it in the EU where soft-where patents don't count for shit!
IranAir Flight 655 never forget!
VMWare manages to sell a proprietary product which is based on GPL'd code. How do they manage? Could it be, because they are literate?
Nice troll.
More likely, it's because they have more faith in their lawyers. It's the FSFs Official Position that linking to a GPLed library must cause the entire program to be released under the GPL. Perhaps VMWare just had more faith that a court would find for them.
Or it could be that VMWare doesn't link to any GPL libraries (the EULA you linked certainly doesn't mention anything about it) and you're fantastically full of shit.
Now, I need a proof of good faith, beelsebob. What BSD project are you working on? ....), and have some chunks of my own code that I've BSD'd (mkbndl, OpenGLCheck ...)
I've worked on several BSD'd Haskell libraries (checkers, Reactive, unamb,
I'm asking because, in my time as a professional programmer, I remember very well that finding a BSD application was a treasure trove: you could steal all the code and pretend to have done the work yourself.
Actually, that's exactly the 1 condition on BSD'd code â" the copyright notice has to remain in tact showing off that it's someone else's work.
So, sorry for the suspicion if you actually work on BSD projects, but I have had it with (fake) BSD fanboys who want other people to write BSD code so they can freeload on. :(.
Yep, and the same thing happens with GPL. It's rather unfortunate that people can't do better than plagiarising
Agreed, which is why it vexes me that my boss worries about open source software (even BSD-licensed!) and thinks sometimes that Oracle is going to sue us for using MySql, even though we don't distribute our software (it's SaaS).
If you introduce even a single bit of Affero GPL code in your enterprise, the FSF and its goons can get bailiffs to raid your data center and do an inspection of all of your code and electronic data.
"fantastically full of shit."
Look, asswipe. Your post made sense, right up to the point you tried to sound superior. You could have left off after you started me thinking. Unfortunately, your oversized ego and your tendency to run at the mouth just makes you look like an idiot.
Now, I'm really, really, really motivated to look at it again to see if maybe the foul mouthed egotistical bastard is right. Uh-huh. Moron.
"Windows is like the faint smell of piss in a subway: it's there, and there's nothing you can do about it." - Charlie Br
I like Mac OS X, but it's not BSD. It contains a lot of userland code from FreeBSD and significant portions of the kernel space are from a BSD. There are several attempts to make a real BSD desktop system. Some are directly using FreeBSD in a distro like setup such as PC-BSD and DesktopBSD. Others are working on a new system, MidnightBSD. By the linux timeline, they have years before they'll be ready. MidnightBSD might end up like Mac OS X, but completely open source.
You don't get a jury in a civil case.
Let's say I'm a trading house. The quicker I can get transactions done, the more money I make. If I can be faster than any of my competitors, I'll make that much more money, because my profitability will attract new clients.
If I pay someone to say... modify the Linux kernel to allow my transactions to process, there's absolutely NO WAY I'm giving it to anyone. Why on earth would I *EVER* give my advantage away to competitors for free? If I've invested millions of dollars into the technology to make money, why would I give it away? Heck, if I'm running a publicly traded company, you can bet your ass I'm not going to have a job for very long with those sorts of executive decisions.
"usually". Not always. My point is simply that the original author claimed it was "free from abuse by those who want to take and not give anything back". That's simply not true.
Semantics.
Lets rephrase it slightly:
"free from abuse by those who want to take and not give anything themselves"
If we modify the party restriction and instead apply it to the 'taker' giving code freely, in general, does your point still work?
It may not require direct reciprocation, but there is an element of preventing abuse involved. In the case where a company extends GPL software and then only sells the resulting binaries commercially, they are still required to provide any customers with the resulting source code under the GPL license, which further allows them to re-distribute it if they see fit. That means there's no effective way to hoard this code or lord it over others. If your derivative product sucks so bad or has such limited applicability that only a handful of people ever buy it and thus get access to the derived code, perhaps they will never re-distribute it, and perhaps the world could care less. But for any derived code with wide applicability or value, enough people will purchase the product and gain access to the code that it's virtually inevitable that someone will legally "leak" it to the rest of the un-paying public, who can then compile it for themselves (again, legally) without paying for the product. This makes it pretty unrealistic to build a business plan around selling software derived from GPL software commercially.
That is the GPL's intent: it is a license for authors who wish to say: "I give this work to the world, and I don't want some greedy person down the line to be able to make money by locking up a modified form of my code from the users of said code, which is something I don't approve of. If you want to derive your work from mine, you must adhere to what I consider to be basic principles of software ethics, the main ones being that you can't sell people binaries and refuse them access to the source code, and you also can't tell them who they can or can't give that source code to themselves".
That's not to say you can't build a successful business around reselling (slightly modified or not) GPL software, it's just that you can't hoard the code in order to force people to pay you. You have to make your money by offering something else: support, services, hardware, etc.
11*43+456^2
Simple decency.
Oh, I forgot. There's MONEY involved. I guess simple human values are mitigated under those conditions, and you are free to revert to exploitation and predatory impulses.
"Speaking the Truth in times of universal deceit is a revolutionary act." -- George Orwell
Pardon, fumbled the link.
Why you shouldn't use the Lesser GPL for your next library
Damn, he's right... Lemme change the LICENSE file...
There... FreeBSD license good to go. Thanks for the reminder, RMS!
otherwise we'd be arguing for the "Year of FreeBSD on the Desktop" instead of Linux.
That's just because we've already seen the "Year of FreeBSD on the Desktop." It's called Mac OS X.
Except as Daengbo points out above us, OSX doesn't use the BSD license for the kernel part, it uses the APSL, which more resembles the GPL than the BSD, e.g. its a stronger "Copyleft" style of license thats more "restrictive" than the BSD. The rest of Mac OS X, the part that really counts!, of course, is proprietary, so the GP's point remains: "Year of *BSD on the Desktop" hasn't happened yet.
The only major GPL projects with corporate contributions that come to my mind immediately are Linux
In the context of the GP's "Year of XXX on the Desktop" reference, this is exactly the point: BSD-licensed OS kernels (*BSDs) vs. Copyleft-licensed OS kernels (Linux). The latter is seeing more corporate interest/support than the former, so far.
On the other hand, many, many non-GPL projects with corporate contributions immediately come to mind. All Apache projects, postgresql, ffmpeg, BSD, memcached, OpenOffice.org, QT, postfix, bind, all Mozilla software, webkit,
Yes, the GP did use the word "projects", thus opening up the whole "open" or "free" software world for inclusion as well, besides OS kernels, and that obviously means there are plenty of examples of BSD-licensed software out there. No one disputes that.
On the other hand, your use of phrase "non-GPL" here plus your particular list of examples is misleading:
ffmpeg = LGPL
OO.org = LGPL
QT = GPL/LGPL (dual-licensed)
Postfix = IPL
Mozilla = MPL/GPL/LGPL (triple-licensed)
Webkit = part BSD, part LGPL
where IPL = IBM Public License, and MPL = Mozilla Public License.
If you're trying to argue *for* the BSD license, then you haven't actually helped your case since just over half of your examples are using some form of a "strong" (or at least "stronger") Copyleft license. LGPL, IPL, & MPL are all Copyleft licenses that are more "restrictive" than the BSD.
If you're trying to argue *against* the GPL license, then first, most people don't think of the LGPL as being "non-GPL", but merely "not quite as strong as", and second, 2 of your examples are actually dual-licensed under the GPL, and third, anyone who wanted to go to the trouble could come up with a list of projects that *are* GPLed.
So your list doesn't really *prove* anything, and as far as the larger context of this debate is concerned, I think you're confusing/conflating two different issues: strong Copyleft (GPL) vs. weaker Copyleft (LGPL/MPL/IPL/APSL), and any kind of Copyleft vs. *non*-Copyleft (BSD). At a minimum, your mistaken assumption that Max OS X is an example of a BSD-licensed project at the outset damages the rest of your response.
The sad truth is, the actual value of the GPL is a lot less than everybody thinks.
If an astute reader interprets your reference to the GPL as "strong Copyleft" and to the BSD as "non-Copyleft", then the real sad truth is that judging by the licenses used by more than half of your own example projects, a lot of people seem to disagree with you!
Will I?
market share for last month from about as good a source as we can manage and yes, weighted by country's population.
Perhaps you have a point, and I unfairly lumped you in with the fud-spewing asshats that make up the masses of Stallman's Zombie Legion. If so, I do apologize.
Either way, you should never let a foul-mouted egotistical bastard stop you from thinking and finding out what's what. There's no point to it. Tell me off, THEN go find out. There's time for both.
Two points:
I think a lot of the reason they *give code back* is because we see companies hire people from a specific project and pay them to work on it. Some of the code remains private, but much of it goes back. This is for many reasons, not the least of which that they want the project to continue to thrive. If FreeBSD went away for instance... every company that uses it as a base is in some trouble. Having it in the wild gives them a whole BUNCH of free bugtesting.
The second point I would make is that I know of many companies that specifically don't release some code back because it serves as a competitive advantage (to the FreeBSD project anyways). That is the downside to such a license.
There are so many examples for this I don't even know where to start. Lets say that I'm a manufacturing corporation and I have a database system and interface that monitors all of my manufacturing processes automatically and warns the appropriate people when a process starts to go out of a controlled state. I don't want my competitors to have this because it's just a huge boon to my output quality and reduces cost by millions every year.
I see the glass as full with a FoS of 2.
And what about GPLed font (namely liberation from RedHat), what if someone uses it under Windows?
Closed apps in closed environment use font, that is GPLed.
Isn't it violation of the GPL license?
I don't think there's anything stopping you from holding copyright on your work and charging a commercial license fee.
I see the glass as full with a FoS of 2.
Microsoft may legally prevent people from using the OS core libraries in a software project that is distributed. There is no doubt about that. But because that would be stupid beyond belief.
Homebrew applications do not link against any of the official libraries of a console, so that argument is not applicable.
Please remember that the code built into consoles functions like a kernel rather than a library. And the difference between the two is that an application never sees the kernel code. In fact, from an application perspective, the kernel features called via interrupts might actually be handled directly by specialized hardware in the processor. That is very different from a library which inherently must be software.
Stylish sheet to fix many problems in Slashdot's D3: https://gist.github.com/801524
Sure it does.
Any changes have to be published under the same conditions that you recieved the
original work. That ensures that changes will be AVAILABLE and freely redistributable.
If you sell a slight modification to a large body of GPL work for an absurd sum, you
can't prevent the person you sold it to from sharing with the rest of us.
Changes that "never see the light of day" are the only exception or "loophole" since
the GPL is primarily focused on "distribution of derivative works".
A Pirate and a Puritan look the same on a balance sheet.
You mean kind of like TrollTech's (Nokia's) QT4.5 library which is licensed under the LGPL? Is that an inferior library? Oh wait it is also available under a dual licensed proprietary license! So does that make it inferior to itself?
--jeffk++
ipv6 is my vpn
You also have to MAINTAIN it all yourself.
You've essentially created your own inhouse custom software.
You've just forked mysql or the kernel and now you get to
support your changes yourself rather than taking advantage
of the rest of the community.
A Pirate and a Puritan look the same on a balance sheet.
Producers of proprietary, closed-source software often ask this question. How does one get around the GPL? The answer is quite simple, even obvious.
Write your own code.
That's really all there is to it. The whole idea behind the GPL, and Free/Libre software generally, is that instead of charging money for the license, the authors expect a different kind of compensation, which is that you agree to share the code and any changes you made to it with the general public. For some reason, this boggles the heck out of people who are trained to look at everything in terms of money and think it's some radical new idea, but it's actually a much older idea than money itself: the trade in kind. It'd be no different if we were farmers trading seeds.
What I find personally disturbing about the question itself is that it all but presupposes unethical intentions. You are asking how you can thwart the spirit of the license while adhering to its letter. If you're okay with behaving unethically and antisocially as long as what you're doing is technically legal, go right ahead. You can probably even ignore the legal implications of outright violating the license, depending on whose code it is -- the FSF has the resources to sue and routinely makes plausible threats to do so, but J. Random Hacker who is offering you a license to some library or other in good faith probably does not have those resources. I wouldn't personally pursue this route, but since you're looking at this in terms of what you can get away with rather than what you ought to do, I thought I'd mention it.
My personal recommendation, however, is that it would be prudent, in addition to ethical, to avoid gray areas like this. If you're producing commercial, proprietary software, the concept of paying for goods and services should not be alien to you. Consider offering money to the author of the library in exchange for a different license. It's possible that they'll say no, but then you should consider offering money to a professional programmer -- a lot of whom are short of work these days -- in exchange for writing a clone. Just a thought.
Proud member of the Weirdo-American community.
Did the BSD networking stack suddenly disappear from the face of the Earth because Microsoft used it? No, it's still there for you to use just as freely as it was before.
People continue to confuse Mad Max style anarchy with "freedom".
That is not "freedom". That's being at the mercy of the party with
the most money or the biggest guns. It's not "freedom" it's a form
of feudalism.
"freedom" in the modern sense is a more balanced or "equal" set of
rights and priveledges shared by all entities. This is what separates
"freedom" from liberty and the rule of law.
A Pirate and a Puritan look the same on a balance sheet.
You could write the wrapper without violating the author's rights, but you'd be violating the public performance right by letting anyone use it over the Internet. Separate issue.
> and Oracle (supplied manpower for the rewrite of the BSD VM system
Oracle, a competitive advantage of FreeBSD over Linux.
You've got to be joking. You need to quit gorging yourself on the cool-aid.
Regardless of how much they might have been willing to tweak FreeBSD, the fact remains
that they have actually been supporting Linux in a meaningful way. This has given Linux
a great degree of legitimacy with a certain class of user that FreeBSD can't ever match
until it gains similar patrons.
Even at face value the given examples seem to be a drop in the ocean and really quite
limited (kernel only) when compared to what's out there for Linux. This narrowminded
approach seems to capture much of the difference between FreeBSD and Linux (and users).
A Pirate and a Puritan look the same on a balance sheet.
First of all GPL has not yet been deeply tested in a court so it is not easy to say what will happen when it is. But let's start following mental experiment:
Writing closed source application that talks to a server (like something.google.com) that runs GPL application is definitely OK.
So what if I get such GPL server and install it on my own server and let my application talk to it from any place around the globe? OK.
What if I let my customers run the server themselves and also give them my (commercial) application to connect to it? Still OK.
What if they run the server on the same computer as my own application? It is still server/client design, but no network communication happens. OK or not? Who knows.
Now why bother with two running processes? Let's keep the "server" and the application logically separated. Don't not link one to other during compile time or during runtime, but execute them both in the same process and exchange data over char[] buffer. Almost no change to the previously accepted architecture. Huge difference in the meaning of what is being done. OK or not?
Imho, unless there is a court decision, nobody will know how much one can tease GPL and still be "not guilty".
Interesting. I used an e-mail gateway product that had a modified a modified version of Sendmail for their e-mail gateway product. The vendor declined to share the source code with me. What recourse could I have possible had?
You mean like the ffmpeg that everyone else uses to make multimedia as easy to deal with on MacOS as it is on Linux?
The name was devised by RMS. What he thinks of as "lesser" has nothing to do with the vernacular.
A Pirate and a Puritan look the same on a balance sheet.
Insisting on what is little more than a restated "equality under the law" is dogmatic?
Who knew?
Where are you posting from? Some bastion of communism that slipped under the radar?
Actually, in the manner in which the "dogmatic" fellow described the situation the
GPL seems like nothing more than the older school notion of the actual copyright
statute. Non-profit use is fine and is not worth "prosecuting" people over but you
better not try to be a for-profit pirate or the consequences could be quite severe.
A Pirate and a Puritan look the same on a balance sheet.
I've seen this kind of thing before, and it surprises me that so many people have such a deep misunderstanding of copyright law.
The GPL ***CAN'T*** define what a derived work is; it lacks the power to do that. Congress (not FSF and not Microsoft), through copyright law, does that.
Reading pages at FSF may clarify the issue, simply because those pages are written by presumably well-versed people (though beware: they may try to persuade you, rather than inform you).
"Believe me!" -- Donald Trump
Yup. That looks like DESKTOP marketshare numbers.
For this purpose, the fact that "MacOS is a BSD" is largely IRRELEVANT because
it is an old and well established platform that predates many of the components
in the current version of MacOS by quite a bit.
MacOS didn't spring into existence fully formed yesterday. It's been around for awhile.
Plus the OP specifically mentioned considerations other than those that assume that the desktop is the entire universe.
Attempting to conflate MacOS with BSD is really quite disingenuous and even kind of demonstrates the whole point of the GPL anyways.
Although MacOS could be built on the Linux kernel and they could still have a proprietary userland.
A Pirate and a Puritan look the same on a balance sheet.
...also. Much like RMS likes to whine about Linux being mostly GNU, MacOS/BSD is mostly the proprietary runtime owned by Apple Corp.
It doesn't fit into a wider MacOS software ecosystem like Linux does. Since
Linux is mostly GNU, it shares many of the same basic tools as are used on
other Unix. Thus, you can have Unixen from disparate commercial vendors that
can all end up looking the same because they share the same toolchain.
Even without the GNU toolchain, there is a shared open specification for the
userland so that you could build much of the stuff on Linux that exists on top
of GNU on any other Unix.
This is not the case for MacOS.
At best you end up with something that comes off much like installing Cygwin or a commercial X server onto Windows.
An "Open MacOS" might be cool.
Infact, the FSF started such a project before Apple announced it would be assimilating OpenStep.
This was the first "Linux desktop" project announced and it predated GNOME and KDE.
A Pirate and a Puritan look the same on a balance sheet.
Nothing, though some people have argued that the law's definition (*) of derived work may end up applying anyway. Of those people, you can totally ignore the people who cite the GPL's wording, as though licenses actually have power prior to someone agreeing to them. (The very idea! You agree to a license and then obey it, not the other way around.)
BTW, the neat thing about separating your program, is that if you can do that without too much trouble, then you've also just made your program multi-process. What's not to like about that? If the GPL encourages people to develop multi-process apps, all the more reason to like the GPL. ;-)
(*) This is almost a joke, though, because the law's "definition" of derived works is so incredibly vague that it's essentially not defined at all. It's almost totally up to judges' whims, and it shouldn't surprise anyone if they all contradict each other. And that puts you in a hairy position, since whoever holds the copyright of the library is going to have the power to take the initiative in a case against you, and shop for the most favorable jurisdiction in which to sue you.
As copyright owner of this comment, I authorize everyone to defeat any technological measure which limits access to it.
In other words, MacOS is not open in any meaningful sense of the term.
It is exactly the type of "walled garden built with the help of free labor"
that GPL zealots always have whined about with regard to the BSDL.
What's the point of MacOS if I just end up turning it into a Linux clone?
Really? I have 3 Macs so this isn't just an academic/rhetorical question.
If the first thing I am going to do to overcome the inherent limitations
of MacOS is to start installing Linux software then what's the point really?
A Pirate and a Puritan look the same on a balance sheet.
The reason for the GPL is not to "protect" code or keep code free. Code will be free forever under any open source license.
The GPLv3 claims to be irrevocable, but how easily will this irrevocability stand up in court? Take the following scenario:
How can Bob's attorney convince the jury that Bob had actually obtained a copy of the work prior to the license change? Worse, how can Bob afford to hire an attorney in the first place?
G++ was started as a proprietary fork of GCC, and could be liberated because of the GPL. Qt has grown and flourished under the GPL for years, enabling Trolltech to give us a great product for free and make serious money. KDE is mostly GPL too, so is MPlayer and almost two-thirds of projects on Sourceforge. And there is that Linux thingy, that happens to overshadow any *BSD, and has massive support from industry partners.
Really? There is a nice website to make sure they do play by the rules. It seems to be working.
You either live in a fantasy world or you need to give me the name of your company so I can send them my CV. Are you serious? Have you got any idea of how many PHB's would freak out if you sent out company IP without being obliged to do that? At the very least, there is a small hill of paperwork to fill in; if you are on bad terms with some higher-up, it might even be used as an excuse for firing you. It is perfectly possible that a boss with programming experience understands that there is no point in maintaining a separate proprietary fork of a BSD project to fix a few bugs, but there is no way in hell he's going to allow you to contribute anything that required a significant amount of company time and effort.
The sad (for BSD) truth is another: without Stallman and the GPL there would be no Linux, no KDE, no Gnome, no GCC, no Free Software. Corporations are there to make money, not to gather "good karma": you either force them at legal gunpoint, or they will run away with the loot. And if they didn't, their shareholders could sue them for that.
Victims of 9/11: <3000. Traffic in the US: >30,000/y
See: why clisp is under gpl"
In this case it is more likely that I forked PostgreSQL, but what's your point? Any company that has trade secrets by default accepts that they are going to maintain it themselves or maintain it with consultants signing NDAs. That aside, what is to prevent me from using mySQL or PostgreSQL without modifications? PostgreSQL is under BSD and there's nothing in the GPL that says I have to make my source available to anyone unless I distribute it, which I certainly would not be doing unless it became significantly inferior to a new system I have developed and I wanted to recover some of the cost of development from the previous system.
I see the glass as full with a FoS of 2.
I can completely understand why you'd want to license an app under GPL. But I often don't see the point in doing so for libs. I think a lib is more likely to get play and support if it is LGPL or GPL-with-linkage-exception. For example, my company produces *very* niche test equipment (simulators). In a 1M line app, there's one place I need to do some (inverse) FFTs as part of a particular feature's initialization. FFTW would be the first thing to think of, but alas I cannot use it: GPL-only. There's a commercial license which my company cannot be bothered to pursue, since we can use an FFT I coded years ago from a math textbook, slow, but certainly fast enough for the seldom used feature esp. with CPUs so much faster than they were. How on earth does using a single math function call in an obscure feature of a 1M line app make the app a "derived work" -- only in the mind of the EFF.
I make it a point to do what I can to help the various LGPL or GPL-with-linkage-exceptions we do use. Most recently fixed a math library that was not 64-bit safe and sent the author revisions -- and that's even for a do-what-you-want non-GPL library.
Why can't the app be GPL *and* paid software? The developer doesn't even have to put the code online, they just have to put it in the same CD as the binaries, and they can charge whatever they want.
The developer sells one copy, which the first customer redistributes to the world. So how could the developer recoup its expenses from only one sale?
The GPL is not a problem at all for companies that do not distribute software.
But has there been a legal ruling either way as to whether companies "distribute" software to their employees who work from home?
That's a different discussion.
"When I first heard Daydream Nation it quite frankly scared the living shit out of me." -- Matthew Stearns
"You can't link GPL code with non GPL compatible code, library or not."
The person asking the question, as far a I can tell, did NOT ask about linking. He asked about writing one app, which would be GPL, which *would* link the library in question. Then, write another app, which is NOT GPL, which uses something like pipes, networking, or other forms of IPC (interprocess commmunications) to allow the proprietary application to 'communicate' with the GPL 'wrapper' of the application.
This would probably be legal, according to the Free Software Foundation: the GPL FAQ has a section on Plug-Ins which is probably the most responsive/similar to this question. Per the FAQ:
"It depends on how the program invokes its plug-ins. If the program uses fork and exec to invoke plug-ins, then the plug-ins are separate programs, so the license of the plug-in makes no requirements about the main program."
How can this be possibly modded insightful? Isn't this the same place where every time stuff like piratebay are discussed people fall over themselves arguing that downloading music/movies is not stealing?
There is nothing lost, so how could it possibly be "stealing"?
Agreed, it was an unfortunate choice of words by me. Though you may want to take note of the fact that there are multiple people discussing on this site, who don't all hold the same opinions. Thus it's nonsensical to argue that user B must not hold an opinion Y because user A held opinion X in a different discussion. Keeping this in mind will help you make sense of this place.
Nice effort in sidestepping my more important points about file format or protocol incompatibilities, though.
"When I first heard Daydream Nation it quite frankly scared the living shit out of me." -- Matthew Stearns
Hi, here is the discussion:
http://stackoverflow.com/questions/1260591/about-mysql-gpl-and-lgpl
What do you think?
Cheers,
"I understand that if I build an application that links with a library that is licensed under GPLv2, I must also make my application GPL2"
.. provided that you also .. Accompany it with the complete .. source code
You understand incorrectly, there are provisions for linking to GPL libraries that allow for excluding your code from the section 3 provisions of the GPL.
1. Exception to Section 3 of the GNU GPL. You may convey a covered work under sections 3 and 4 of this License without being bound by section 3 of the GNU GPL.
--
3. You may copy and distribute the Program
"mmmm, freedom to take your TCP stack, bundle it into my product, gain a monopoly, tweak my TCP stack a little to be incompatible (becoming defacto standard), and then sue your ass if you try to copy or reverse-engineer my incompatible changes."
And..what's your point. Your original code is still available for free. The proprietary changes a company makes is code they wrote (IE: not yours).
"We really need to get away from pretending we are special and will become millionaires with our brilliant (read stupid to everyone else) idea. Lets agree that free/open software is done to benefit us all."
Tell that to the many companies the FSF sues for infringement.
The developer doesn't even have to put the code online, they just have to put it in the same CD as the binaries, and they can charge whatever they want.
That *might* work for an expensive peice of software that is only sold to a few customers.
It won't work for mass market software, one person will buy a copy and redistribute it (yes this happens anyway but since the software is GPL it's legal). Furthermore they can even rebrand the software so that users associate it more with them than with you.
note: i'm known as plugwash most places but i screwd up registering that here somehow in the past and now can't register
In what possible way is it tyrannical? Are you being forced by someone to use my code and therefore to accept my conditions?
Because in any realistic scenario, customized code costing $1,000,000 probably contains more than $1,000,000 of trade secrets of the customer and thus it makes no sense to sell it. In fact the original author is probably not allowed to sell or redistribute it either (I believe the GPL would allow this as they are only required to distribute source to customers and a contract saying nobody else can be a customer can still be enforced).
The question is, who is the freedom for? If you want the freedom to remain with the USERS of your software, you release it under the GPL, which doesn't allow developers to take away the USERS' freedom. Sure, it's not freedom to the developer, but that's the point.
If you want freedom for the developers to do whatever they bloody well please with your code, you use a BSD license. They can take it, change it, put a padlock on it and sell it. That doesn't provide freedom for the people using the software, but it provides freedom for the developers.
I actually thought this was pretty simple...
He can continue to merge in any changes that the community makes, and certainly can take advantage of them.
Also if there is some bug or feature in mysql they need, they can make a stripped-down version of their application, such as an otherwise useless page of code that demonstrates the desired feature or bug, submit that, and hope the mysql guys fix it.
They could also fix mysql itself, contribute the fix back, and if it gets incorporated into the main source they are in exactly the same state but their code is still secret.
Yes there are LOTS of such licenses. In fact for a long time the majority of available source code was under such licenses.
The fact that they are not popular is an indication that people don't like them.
The term "lesser" is because RMS thinks the license is worse, not the libraries, you idiot. In fact libc is considered superior in the cases where there still remains a competitor such as on Solaris.
Personally I think he is being an ass with this and prefer calling it the "library" GPL like it was named originally.
There's a big difference between would could be done and what is done. As the GP said, there's no guarantee that the changes will ever be "given back" to the community.
Even if someone attempts to give back, there's no guarantee that the maintainers will be interested in using it.
The bottom line is that if you're concerned about your code being used without payback of some kind, you shouldn't be making it open source regardless of the license.
For a company, maintenance is driven by the companies needs, goals, and schedules. The "community" doesn't necessarily care about those things and so community maintenance isn't very useful in many cases. Of course there's no guarantee that the community is interested in maintaining your application anyway.
But if they could make copies of your bottles and sell them, what would be the problem? Metaphors that use physical stuff are the tactics used by the RIAA. As for whether the guy "might reasonably want to restrict use to other people who want to share code for free", if that is so he would have used GPL. Simple really. Now fuck off and stop wasting our time.
The argument about "stealing" is totally bogus.
Copying a Metallica disk and clearly labelling that it is Metallica and that they wrote the songs is copyright infringement.
Copying a Metallica disk and claiming you wrote and performed the songs is stealing attribution and certainly is stealing. If you are successful in doing this you would get all the rewards of making that music and Metallica would not get them, so there certainly is a tangible asset transfer and thus theft.
For some reason all the anti-GPL people seem to completely ignore the distinction.
Technically the GPL is violated a million times a day. Any bittorrent site distributing a GPL binary is violating it by not simultaneously distributing the source code. Anybody installing Linux and not putting the source code on the machine is violating the GPL. Yet nobody is trying to sue them and nobody is saying they are "stealing".
Public performance rights only apply to audio or visual portions in general, and then only to the actual work itself. If the wrapper is sufficiently abstract, there is only a public performance of the wrapper and not the software itself. I think Mathematica has whined about people doing this sort of thing, but AFAIK the only thing preventing it is the EULA, whose strength varies by jurisdiction.
"Linux is only popular because of the GPL."
I think it should be "Linux is popular only because of the GPL" (but I'm quibbling and risk being corrected for my mistakes).
I think that statement is mostly propaganda.
Developers might have been attracted to Linux because it was their first opportunity to collaborate on a new UNIX derivative from the ground up.
BSD had already been done before the Internet was available and reportedly didn't have a welcoming culture.
Once Linux starting catching on as the UNIX for the next generation, it's popularity snowballed.
If it had been licensed under the BSD license IBM could certainly have created a proprietary version without giving back, but to what end? They already had their own perfectly adequate UNIX system.
I doubt that Linux developers would just stop development because their grandfathers' Big Computer Company was competing with them.
"In the end, their software will always be better than yours because they build upon your work."
This is where your argument falls apart.
yeah but once the second library is under GPL your first library now linked against that and now would need to be GPL. This whole thing does not make sense, it's like you step on my lawn so your shoe belong to me, now your shoe step in your house so the house belong to me.
"The purpose of the GPL is to keep the project as a whole "free" not just the original version."
The word "project" implies some kind of structure or organization to design and implement it. If I buy some wood from a construction company and make a carving of RMS face, is my carving part of some construction company project?
A group that forms the core development for a project maintains control of that project even if somebody forks it to create their own proprietary project.
Mad Max ... the most money or the biggest guns
No, no, no.
If you're going to use a Mad Max reference, the *only* proper analogy allowed here is: "the biggest V8".
It is worth citing the key quote by RMS in that thread:
I think the same position applies to the submitter's question in this story. He is writing a piece of software that clearly shows the intention to incorporate the GPL library in question, and using a subterfuge to claim that he is not doing so.
As a few other people have said, the real question here is what counts as a derivative work, and this is a legal, not a technical question.
Are you adequate?
If it had been licensed under the BSD license IBM could certainly have created a proprietary version without giving back, but to what end? They already had their own perfectly adequate UNIX system.
They *still* have their own "perfectly adequate" proprietary UNIX, so why are they contributing to Linux despite that? This question is especially pertinent here when you consider that much of what they're contributing to Linux actually comes from their own proprietary UNIX!
I doubt that Linux developers would just stop development because their grandfathers' Big Computer Company was competing with them.
Uhh, IBM *is* one of the "Linux developers" now. Try grepping the Maintainers file for "ibm.com". You might be surprised.
IBM isn't worried about competition from Linux, they're worried about competition from their corporate *rivals*, a worry that goes away, however, if they only release their stuff under the GPL, since then their *real* competitors can't use their own stuff against them.
I think you've completely missed the GP's point.
You miss what reciprocity is. In effect the reciprocity of the GPL is:
I'll get contributions from people working on their own projects generally unrelated to mine
and in exchange
I'll give contributions to people working on projects generally unrelated to mine
I notice you have a high number. Take a look at what happened to X-Windows during the 1980s under the MIT license. Those licenses were a detriment.
Changing 10% can often be enough to create a new standard version of a piece of software and effectively close source the original. Look at the history of X-Windows where this did in effect happen.
Why do you think it "works"? There were lot of free OSes and BSD386 (father of Free and Net, grandfather of Open) started a bit earlier. There were also other open OS projects that weren't Unix based. You are begging the question here.
This is the *point* of open source software, to be generous, and let everyone benefit from your work.
No, the point was to create a free Unix like operating system.
I've contributed code directly to Darwin. There are lots of Apple projects with other people involved. There are also lots of parts Apple doesn't write at all, Apple as much as possible doesn't want to write deep components and would rather just integrate from the broader community. I would say Darwin is primarily an integration project not a an authoring project. And even where it is an authoring project they want to make it integration if they can.
Don't know if that supports your point or not.
Actually you can use Apple's open source X which much cooler than Xorg's version on a Mac. It has all sorts of hooks into Aqua, Cocoa and Carbon.
I wrote the LGPL v1 and badgered RMS into allowing it (John Gilmore thought up the great dynamic linking clause). RMS's biggest objection back then was exactly the case you give.
I still think in the balance the library license is a net positive for the FSF's cause. But this hinges on the definition of a "derivative work"
Technically true but in practice it doesn't really work that way. Nobody is going to pay you a million dollars for a derivative unless it is substantial.
In practice that means the original developer is probably going to find and fix bugs in the original source. The client is going to want to update from time to time and the developer isn't going to want to have to personally test and patch up any code in those updates he doesn't have to so bug fixes for the original source will be contributed back. When updates do come around, it will reveal a whole slew of additional bug fixes and small behavior improvements that again will likely be contributed back for the developer/clients own future benefit.
The stuff that won't be contributed back is likely proprietary to the single client in this case so contributing it back wouldn't be especially useful anyway.
Now if you did the same for software that is going to be sold to multiple clients not only will you have made changes more likely to be accepted into the main project in the first place but you will have increased the odds that at one of those organizations will decide they would rather have the community update the app for them for free than keep paying you to do it.
Wrong. MySQL claimed that if you used the GPLed MySQL client libraries then your application would be a derivative work. They never claimed that any application accessing a MySQL database would be GPL, only ones that used their GPL client libraries.
Yeah, I was thinking more about things like adventure games, where the public performance right is clearly implicated. It's hard to invoke with an engine like Mathematica, which provides factual results only.
You can sell GPL software for any rate you want.
In fact, all custom code that I have sold to companies I coded and then sold them a GPL license to the code instead of coding it on a contract for hire.
Most companies don't contract you to write code so they can own IP. They contract you to write code so they can perform a task.
If you explain to them that you will license the code under terms that gives them full access, the ability to make any changes they wish and hire anyone they want to make those changes in the future they will be happy.
In fact, they will love you even more when they find out you work this way so that you can use the code to save your clients money on future development and that their own project will cost them less because of code recycled from previous projects that were sold under the same terms.
The community for a given derivative is its users. By definition the users will have a copy of the dervivative app and therefore the source. It was never intended that anyone and everyone should be required to have the changes.
In practice though, even private development will result in bug fixes and it will be in that private party's interest to pass those back to the original project so they are maintained by the community and don't have to be manually patched and merged in with each update.
Spoken like someone makes their living off closed source software. The rest of us have no use for it.
In practice, however, it seems volunteers and companies contribute a lot more to GPL'ed projects than to BSD'ed ones, otherwise we'd be arguing for the "Year of FreeBSD on the Desktop" instead of Linux.
Perhaps the fact that Linux was there earlier than FreeBSD might have affected things just a little bit as well...
"I (and I'm sure I'm not the only one) use Linux because it WORKS and does what I want it to in the situations that I apply it to."
And it WORKS because the GPL has allowed and required contributions to add all that glorious functionality you leech.
The real answer is that while FreeBSD is a fine set of code it really doesn't offer anything that Linux doesn't offer. On the flip side, Linux offers numerous features and as a platform has much software available and is much more polished.
The only reason to use BSD is to find stable code you can exploit in your closed source app (i.e. Slave labor). Or for the masochists who want to avoid polish.
Ms-PL is actually a fairly interesting license (and not at all company-specific, unlike, say, MPL) in that it's somewhere in between GPL and BSDL - it lets you distribute binaries (either original or derived) under essentially the same limitations as new-style BSDL (i.e. no misattribution of copyright/trademarks, but otherwise do what you want), and it doesn't force you to provide the source - but if you do provide any part of the source (don't have to provide it in full), that source must be provided under Ms-PL. It also has a patent clause along the usual lines.
"No it hasn't. That guy was kind enough to give it away in an open way. This is the *point* of open source software, to be generous, and let everyone benefit from your work."
Says the guy who wants something for nothing. Maybe that is why you distribute open code but it isn't why I distribute open code. Even most charities are really in it so somebody somewhere along the line can get into a lower tax bracket.
"Then he (a) is not an open source developer (b) should use a closed license like the GPL, and stop claiming to be open."
Feel free to write your one man open license requirements and one man definitions. The rest of us aren't buying it.
The GPL allows anything except selfishly exploiting the gift you have received by not sharing with the same spirit in kind. Open source software does not exist so that you can effectively utilize slave labor to decrease your development costs and increase your profit margins.
In other words you are a freeloader who wants other people to write code for you so you can steal it and abuse your users by denying them the source code.
and choose a different license then.
Uhmm, did you notice that the title being used for this subthread is "Re:GPL Fanatics"?
Honest mistake, sometimes I don't notice when the title has changed either...
That isn't true. You do not actually have to physically provide the source with each individual binary, you only have to include notice it is available and provide means for the recipient of the binary to receive it if they request it. You can even charge them for your cost to provide them a copy.
"The purpose of the GPL is to keep the project as a whole "free" not just the original version."
A group that forms the core development for a project maintains control of that project even if somebody forks it to create their own proprietary project.
Of course, with a GPLed project, it *can't* be forked to a *proprietary* project, which is precisely why some prefer it. Another GPLed fork is no big deal: its still under the GPL, its code remains "free", *and* modifications in one can still be used in the other...
That last bit about modifications is probably why GPL forks don't happen so often.
I don't know. The things most keeping me from using FreeBSD instead of Linux on the desktop are closed source, ironically (NVidia blobs and Cedega, mostly)
I'm not a BSD user, but wouldn't you be able to use FreeBSD's binary compatibility to run Cedega, at least?
Convert FLACs to a portable format with FlacSquisher
in the EU where soft-where patents don't count
Not until the EU can explain why they "allow" them, just don't "enforce" them. That doesn't make any sense: why allow software patent application if you never intend to enforce it... unless the "enforce" part is just an implementation detail left for v2.0 that is on its way?
Attention Moderators: The Troll moderation does not mean "I disagree". If thats what it *meant* then thats what it'd be *called*.
you might consider that people claiming to be open WRT the GPL may imply open and can never be closed
This is a perfectly polite, and perfectly VALID *opinion*, whether you agree with it or not. If the parent is a Troll, then so is the grand-parent, the great-grand-parent, and virtually every freakin' post in this entire discussion thread!
*sigh*
Indeed. Somebody's failing to distinguish between two things:
The terms of the GPL say that derived works must be licensed under the GPL. The FSF takes the position that a program that links to a GPL-licensed library is a derived work of that library. This doesn't preclude them from taking the position that, say, an application that calls a GPL-licensed service through SOAP isn't a derived work of the SOAP service. (In practice, I'd expect them to take positions that depend on the details of the application and the SOAP service.)
Are you adequate?
IBM became involved with Linux because it was becoming popular and they were becoming more of a service company.
If the GPL was so important to them they could have used GPL'd code a long time ago. They didn't because until Linux came along, there was no business case for it.
Having made the commitment, IBM naturally invested in it, but only after the original developers had made it a force to be reckoned with.
This is, at the very least, not the position that the FSF takes. And I agree with them.
It comes down to how you interpret the part that says "major copyright-protected elements of the earlier work." You're reading "elements" as actual pieces of code. Copyright law in general, IMO, doesn't read the term "elements" as narrowly as you're doing. For example, the elements of a novel isn't just the words and their arrangement; it also includes the characters and the plot. You can't publish your own Harry Potter novels commercially without permission because the character and tons of background plot elements are protected by copyright. That your novel shares no substantial amount of text with the originals doesn't come into the argument.
So for example, the FSF can take the position that the call interface of a GPL-licensed library is a major copyright-protected element of the library itself, and that by using the library in your application, you're incorporating that element of the library into your work. Or more generally, if your application was written to use the GPL-licensed library, and cannot work unless linked with that library, then your application incorporates the functionality of that GPL-licensed library, and that therefore to distribute it, you must license it under the terms of the GPL.
Are you adequate?
The whole point of this sub-thread is comparing the GPL to the BSD. I'm just saying that "keeping the project as a whole "free"" isn't a logical reason to use the GPL instead of the BSD because in both cases forks done by other individuals aren't part of the project.
If this were not the case, I could change one byte of the Linux kernel and claim I should have commit privileges because my code is part of the Linux kernel (i.e. part of the project).
For example? Seriously my question wasn't rhetorical or anything!
The fact that they are not popular is an indication that people don't like them.
I doubt its that simple, id guess that the licenses where confusing to use and using them with other copy-left licenses caused problems!
IranAir Flight 655 never forget!
LGPL v3 has the following:
Yep, you're right, it goes into more detail (I didn't check it - just looked at the GPL), but you'd almost *expect* the LGPL to go into more detail, it *has* to, since this is why it exists (explicitly allowing more interaction with other non-GPL code).
I'm still not happy about "linking", though: can you provide a waterproof definition of linking in the context of Java programs?
If you mean "waterproof" in a *legal* sense, I don't believe thats possible for *any* language. :)
Thats what I was referring to at the end about "vagueness of the copyright law itself".
As far as I'm concerned a licence should be as short as it's possible to make it while communicating clearly what permissions it does and doesn't grant. Trying to make a licence too general results in it becoming longer and harder to understand. Using specific terms with agreed meaning is simply good communication.
Ok, I agree with all that, however the point I was trying to make is that the lack of "specific terms with agreed meaning" is inherent in the copyright law itself. Copyright licenses get their meaning and value from copyright law, they do not "stand alone".
Simple (probably bad) analogy: The copyright licenses are the "frame of your house", and the copyright law is the "foundation that you build your house on". No matter how strong you make the frame, if the foundation has a weakness, you're still in danger of losing your house, and sometimes, you have to *try* to overcome a possible weakness in the foundation by reinforcing the frame, which would *not* be necessary if the foundation was known to be solid.
The reason licenses aren't clear and easy to grok is because the underlying law isn't *helping* to *make* them clear and easy to grok.
The absolute worst offender, when it comes to unhelpfulness, is copyright law's concept of "derivative work". The meaning of this changes almost every bloody time the Supreme Court, or an Appeals Court, makes a decision concerning it! All the arguments elsewhere in this thread about linking are basically arguments over *technicalities*, and *none* of them can be clearly answered until we, or at least our lawyers, have a clear and precise legal definition of what a "derivative work" is. Alas, technology is moving much faster than the law, and the courts aren't able to update the law fast enough to keep up with reality. This is our current dilemma.
Regardless of what zealots would like you to think, there are limits as to how far GPL's effect can go and no one is going to challenge them.
If the wrapper is network based for instance, i.e. you create a wrapper (also GPL'd) which wraps readline into a network service so that another app that isn't GPL can communicate with readline via sockets ito another process, GPL can not and will never be applied to your library connecting to it.
No one will ever seriously contest this, as doing so means every chunk of software involved in the Internet would all have to abide by every license involved which is impossible anywhere except some fantasyland that Stallman and his cult live in.
So yes, there are ways to wrap GPL apps/libraries and get around the requirement to GPL the other code. The advantage you have with GPL is that they can't revoke your license because they don't like you, or rather, the disadvantage to authors of GPL code.
Microsoft can revoke your license pretty quickly or at least no grant you any new ones if they don't like how you've worked around their rules.
I hadn't really thought about working around GPL this way until you mentioned it, never really had it become a problem for myself. As a general rule if theres any serious library that you would want to link against that is GPL, there is another actually free BSD/MIT/Apache style library that matchs it well enough so you don't have to use the GPL version. I've yet to run into any instance of a library of any importance or side that was GPL only and didn't have a free/open source counterpart. And yes, I'm saying GPL isn't actually free or OS, if that bothers you then flame away cause it won't bother me.
Persistent Volume manager for Kubernetes - https://github.com/dwimsey/openshift-pvmanager
Except that we all have to have a general idea of what each word means to each other or the entire communication channel is as useless as cosmic microwave background radiation or static is for, well anything really.
There IS a dictionary, and it does have acceptable meanings for words. You don't get to redefine free to mean the color blue just because there isn't a god given dictionary that says otherwise unless you want to be considered an idiot by everyone else.
And seriously, $DEITY-given dictionary? Are you 15 trying to be trendy and anti-religious? You spent more time trying to be cute than thinking about how retarded your statement actually was.
There isn't really any bickering about what free means, there is just a GPL vs everyone else argument about what free means. GPL means free except when GPL disagrees. The idea behind GPL is great. GPLv2 is great. They have their place in the world and are very useful. They are not however free as in libre for anyone, the license is restrictive. Accept it and the argument will stop, keep denying it and people are going to continue calling you out on it.
No matter how long you hold your breath, stomp your feet and ask daddy Stallman to beat up those who disagree with you, GPL will never be 'free'. You don't want free if you want GPL. The problem is you want GPL and you want to tell everyone else that its in the name of freedom.
People who scream that GPL is free are nothing but politicians who suck as the only ones that believe the chorus line they sing are ones that already are GPL fans, not anyone you are trying to convert. Just stop trying, you don't need to convert anyone, your cult is big enough.
Persistent Volume manager for Kubernetes - https://github.com/dwimsey/openshift-pvmanager
All very good points... and happily, none of them contradict mine.
The whole point of this sub-thread is comparing the GPL to the BSD. I'm just saying that "keeping the project as a whole "free"" isn't a logical reason to use the GPL instead of the BSD
And my point was that a BSD project can have a proprietary fork, but *not* a GPLed project, thus there *is* a difference: a *proprietary* fork *might* end up meaning no reciprocation, no give-back, no collaboration on a common base... it all depends on the "good will" of the company doing the fork.
Right or wrong, some people, *and* other companies!, don't put much faith in seeing "good will" from a profit-motivated corporation, especially ones, like, say, MS...
What I meant was that a bittorrent node splits up things into blocks and thus technically it is very likely it is transmitting a piece of GPL compiled code without including the necessary notice of availability of the source.
Less theoretical: I suspect an awful lot of installed Linux systems do not provide any indication of how to get the source code and thus the installer also violated the GPL. This is especially true if the end user wants to actually recreate the code they have installed, rather than perhaps building a different or generic distribution of Linux.
The original Solaris license for one.
GPL incompatability was not what killed them, it was the reciprocation agreement. Witness the CDDL, which is doing ok, although GPL incompatible.
"Less theoretical: I suspect an awful lot of installed Linux systems do not provide any indication of how to get the source code and thus the installer also violated the GPL"
That wouldn't be true of any of the major distributions, they all include such notices on the distribution media.
"What I meant was that a bittorrent node splits up things into blocks and thus technically it is very likely it is transmitting a piece of GPL compiled code without including the necessary notice of availability of the source."
You are right that pieces would be transmitted in chunks, usually something like 64k. But those chunks probably wouldn't qualify for copyright protection as they are.
Even if they did, provided one had the right to distribute the material legally in the first place (and if the torrent includes a notice as we discussed above the seeders would) then distributing the chunks for the purpose of a torrent with the good faith intention of distributing the complete work in accord with the license would also qualify as fair use.
That said, thats just my understanding as an armchair copyright reform advocate. IANAL and you raise an interesting point. I have never heard that argument before.
No I'm claiming the argument is silly, but that some people seem to be comparing such technical infringement with willful plagiarism and considering them to be equal, in order to try to be clever and claim that posters here are not being consistent about copyright.
That said, I do not feel that companies that stick Linux on their machine and do not modify it should be blasted for not releasing the source as though they are somehow evil. Maybe quietly told that they are violating the copyright and it is really easy and free for them to fix it, but it really is not a big deal. This is one area where people here do seem to be inconsistent.
Adopting a body of code is like adopting a child. Its terms change your terms because you _chose_ to _adopt_ it.
The thing people really don't get is that you have _no_ _right_ _whatsovever_ to the code in *any* library outside the terms of copyright law.
The GPL is a grant of license (not a contract) and it is(presumably, in your question) the sole means of receiving that license to use that code. As part of that license you get an unlimited license to use the code yourself for any private purpose, and you get the much-more-limited license to redistributed the code to others IF AND ONLY IF you agree that you will distribute all the source code for the whole shebang you distribute under the GPL, where that code is "linked with" or otherwise joined to the piece(s) you received via the GPL.
When you decide to use that GPL code you decide to adopt the GPL for the existing code you intend to link with that code for any _distribution_ of the combined result, if you don't so decide, then you may not use the GPL code in that distribution. There is no third option.
In the finer points:
The code _you_ already wrote does not become _solely_ GPLed; its source must accompany the distribution with the GPLd code, but it doesn't have to accompany other distributions under other licenses. So if you make two products X and Y out of largely the same code base, but you have the GPL readline library linked with Y, then you must include the entire source base when you distribute Y, but you can still withhold the source base for distributions of X. Further you cannot give someone X and Y and then put a term on the distribution of X that prevents them from using the source code they got with Y. Further still if I get X from you, and my buddy gets Y from you, my buddy can give me the source code from Y and no term of license for X can prevent me from using that code. Even if X had such a term, you would be civilly liable for going after me for using the source from my buddy because your attempt to use X to limit my use of Y means that you were violating copyright law by giving out copies of Y, since you may not add restrictive terms to the GPL. I have a license for X, I get a license for Y from my buddy when he gives it to me, and that license power flows from you (though him to me) unimpeded otherwise it cannot flow from you to him and you are the bad guy.
The larger question of "why would anybody agree to that?" is easily answered.
It's a financially stable cost/benefit transaction. You agree to "pay" for the source code you receive and pass on, by adding to its mass by including your code under the same terms.
From a business stand point it is a nearly perfect deal. you "pay" on the back end, when you distribute, and all you "pay" is the cost of disclosure.
Compare this to a license for Microsoft Wince (I didn't name it 8-) which you have to pay for up front to the tune of hundreds of thousands of dollars, and then pay for it on the back end again with a per-unit-sold fee.
Some people resist the GPL because they beleive that the "value of their IP" in sweat equity is larger than it actually is. This is a delusion that comes from the outrageousness that is the music industry where one months work is supposed to keep paying dividends forever (e.g. how long did anybody work on the Beatles song "Help"? Should it still be paying dividends to anybody? honestly? I wish I could get re-paid every time someone uses my software, but _real_ life aint even supposed to be like that. 8-)
So anyway, for the cost of a $0.38 CD tossed into the wrapper with your product, or a web site that you promise to keep up for seven years, or whatever, you can leverage ungodly amounts of code.
The "but someone will steal my precious" arguments are exactly that crazy. Your precious isn't that precious, and most people would rather pay you for the next version than write that version themselves. The GPL startup cost cannot be beat.
_BUT_ if you adopt the GPL later in the development cycle, yo
Innocent people shouldn't be forced to pay for inferior software development.
--"Code Complete" Microsoft Press
I'm never suggested that there's no difference between a BSD project and a GPL project, only that the "freedom" of their project isn't compromised by forking in either case because forks lie beyond the bounds of their project.
I agree that the terms of the GPL force people to provide their added source code when they distribute it, thus increasing the probability somewhat that the community will benefit, but this has nothing to do with the "freedom" of the original code.
I don't understand why GPL proponents can't just stick with the facts instead of equivocating between the original source and the code added to it.
I don't understand why GPL proponents can't just stick with the facts instead of equivocating between the original source and the code added to it.
Because our whole subthread started with Insanity Defense saying:
The purpose of the GPL is to keep the project as a whole "free", not just the original version.
"not just the original", so I haven't been equivocating, it never has been about "original" versus "added" code, its been about the "project"... at least until you just added that junk in to change the subject.
What if you had a "Bring an MP3" party. You wouldn't be too upset if people listened to more music than they brought. But would you be upset if someone copied the MP3s and sold the copies? That hasn't affected your party in the slightest as nobody was deprived of the enjoyment of the music that was brought.
Want to improve your Karma? Instead of "Post Anonymously", try the "Post Humously" option.
Yes, that's right, that's why I'm BSDing my changes and my software...
This makes it pretty unrealistic to build a business plan around selling software derived from GPL software commercially.
IIRC, there is a company that sells GPL-licensed router firmwares, providing the source only to their customers. If one of their customers leak the source to third parties, and the company finds out about it, the company voids any right to firmware updates for that customer.
I think that the FSF grudgingly conceded that this may be allowed by the letter of the GPLv2, but very far from its intent.
Sigh.
One thing you never seem to understand is that there are other differences between Linux development and *BSD development than the license. I point out stuff that's directly license related, and you attempt to pretend that *everything* is license.
As most other companies, Oracle support Linux over FreeBSD because Linux is more popular than FreeBSD. Oracle used FreeBSD as basis for an appliance due to licensing, but chose to not release the DB for FreeBSD due to the lower popularity of FreeBSD. Linux is more popular than FreeBSD for a variety of reasons, and whether the licensing of either is a positive or negative for popularity is a debatable point.
If you're looking for me to concede some point around this, I'll concede that the propaganda around the GPL is much stronger than whatever little is available for the BSD license, and that this is effective at converting a bunch of people to support the GPL - and may actually be overall enough to make GPLed projects grow more popular, though I haven't seen any clear evidence in either direction. If the GPL propanda makes the GPLed projects become more popular, I find it unfortunate, as I think it's harmful.
Doubting the existence of evolution is like doubting the existence of China: It just shows that you're uninformed.
I'm miffed at whoever moderated this "Troll". Sarcasm should be allowed even towards your scared cow, especially in the context of an actual example that's labeled as a textual demonstration.
Doubting the existence of evolution is like doubting the existence of China: It just shows that you're uninformed.
The right question to ask is: Can YOU make money building your business on proprietary software that might not be there tomorrow?
Yes.
...And people have been doing it for 30 years and still are with 30-year-old software.
The burden of keeping the software running falls on the IT departments, but with the exception of hardware-bound eccentric UNIX flavored software, that's not much of an onus.
Our department uses (extremely domain-specific) MS-DOS accounting software from 1983 running under Dosbox. I recompiled Dosbox with a tweaked version of the Windows SDL library so that it didn't require that annoying stdout window which SDL apps seem to require by default and confuses the hell out of the secretary, set up a dosbox.conf for the program, and created a shortcut which launches the program by autoexec. Now this 26 year old software runs in a window that looks no different than the terminal window she's used to using to connect to our campus mainframes - which themselves are running an ancient version of IBM-made UNIX.
I don't see how that makes it difficult to make money, and the cost for this software was written off 20+ years ago - hardly a bad investment. We've talked to the company that made this software perhaps 6 times in those 20+ years, and each time was to resolve some minor irritation that could have been fixed with some amount of effort on our part, but we paid for support because it was cheaper. If the company had gone tits up a decade ago, we'd have lost perhaps a hundred and fifty dollars worth of time reentering some information to start over instead of paying seventy-five dollars for support. Not that significant a loss.
The certainty that the moment a company goes out of business, all of their closed-source software stops working is ludicrous. Even should the dongle for some antique software stop working, the DMCA (in the US) specifically provides for circumventing that copy protection should the company be unable to provide a working replacement. Other countries have even less draconian laws governing reverse engineering of software. That's not to say that it wouldn't be much easier (and cheaper) to use a piece of software that doesn't have copy protection and provides its source, but to delude yourself into believing that it's impossible to make money with outdated closed-source software is to ignore the fact that the vast majority of the business and governmental world is already doing it.
The land shall stone them with the bread of his son.
What software and contributions are you referring to?
The Mozilla Public License is just such a license (or it used to be, haven't looked at it recently)
If you need web hosting, you could do worse than here
That would be my choice too. The LGPL is all sorts of fun. LGPLv3 is incompatible with GPLv2, so any project that included GPLv2-only contributions is royally screwed when an LGPL'd library that it depends on switches from LGPLv2.1 to v3. It's left with the need to either rewrite the GPLv2 bits or fork the library. Poppler is a good example of this; it's based on xpdf, which is GPLv2-only and is currently about the only half-decent open source PDF library (there's also a nice BSDL Java one, but it's not really usable by non-Java code). Any programs that incorporate PDF viewing capability via Poppler can't use LGPLv3 libraries.
I am TheRaven on Soylent News
And it's been improved by contributions from several UNIX vendors, and the fact that Microsoft used it (for a while - they've written their own now) meant that Windows got an implementation that was compatible with the rest of the world, rather than using its dominant market position to push a proprietary protocol on the rest of the world. Sounds like BSDs lost big time...
The thing that amuses me the most about the GPL is that the FSF claims that Free Software is intrinsically better than non-Free. Given two pieces of similar software, one Free and one non-Free, the Free one is better because it has greater potential for improvement and future utility, even though the non-Free one may have more features now. This being the case, if someone takes Free Software and builds a non-Free application with it, their application will be inferior to the Free original. And yet they also claim that this is something that they need to prevent.
I am TheRaven on Soylent News
The real answer is that while FreeBSD is a fine set of code it really doesn't offer anything that Linux doesn't offer
Of the top of my head:
There are probably more things. The working sound and the stable, properly documented, userland were what made me switch.
On the flip side, Linux offers numerous features and as a platform has much software available and is much more polished.
And these features are? As far as software goes, the only program I have ever come across that works on Linux but not FreeBSD is Valgrind (there's a FreeBSD port, but it's old), and I'd take DTrace over Valgrind any day. In terms of polish, you need to compare FreeBSD to something like Debian. If you're comparing it to something like Ubuntu, then PC-BSD is a better comparison (a FreeBSD distribution designed for the same sort of market as Ubuntu). Last review I read (on OSNews - google for it) comparing the two recommended PC-BSD over Ubuntu for new users. Oh, and because it's not GPL'd, the PC-BSD install CD can include the nVidia drivers and have them work as soon as it's installed.
Nice troll though. I've wasted far longer replying than I should have.
I am TheRaven on Soylent News
The XNU kernel used on OS X is not BSDL, it is APSL and includes some BSDL (mostly from FreeBSD), some CDDL (from OpenSolaris) and some proprietary components (mostly drivers).
I am TheRaven on Soylent News
G++ was started as a proprietary fork of GCC, and could be liberated because of the GPL
You are confusing C++ with Objective-C. It was the Objective-C front end, not the C++ front end, that was written as a proprietary extension and liberated by the GPL. The company that wrote it was not forced to release the corresponding runtime library, so the FSF wrote their own. Apple then bought them and continued to develop their fork. We now have the situation where only Apple's fork supports any of the modern Objective-C features and then only on the Apple runtime. The GNU version of GCC doesn't support any of them. Fortunately, clang (a BSD-licensed Objective-C compiler) supports almost all of the Objective-C 2 features with both the Apple and GNU runtimes. So, uh, yay GPL!
I am TheRaven on Soylent News
If it does, it's not due to the GPL. 90% of all software is developed for in-house use and not distributed. The requirement for publishing changes to any GPL'd contained in such software never kicks in because it is never distributed. If a company chooses to release their changes upstream it is because they have decided it's cheaper to do so than to maintain a fork, which is exactly the same choice that they'd make if the code had been GPL'd. See for example the (unreleased) Google filesystem for Linux (not released because it gives Google a competitive advantage) and the contributions made by Yahoo! to FreeBSD (released because they were not core to Yahoo!'s business).
I am TheRaven on Soylent News
No, the first library does not link against the second. The second links against the first. Essentially the second library is an extension or plug-in. The first library works in it's entirety without the second.
Try reading the post you responded to â" the one in which I list a bunch of stuff I've BSD licensed.
My apologies on that point. For some reason when I read the comment I only saw from here down:
"Actually, that's exactly the 1 condition on BSD'd code Ã"
It looked like you had dodged the question but looking back it displays correctly and I now see you did not. Slashdot has been behaving and displaying oddly at times for me lately on my laptop... maybe its the screen res. Not sure.
In any case. The BSD license is for those who contribute as a form of charity. The GPL is for those who contribute to scratch an itch and/or believe that philosophically all users should be entitled to the source for the applications they use and to be able to modify and fix those applications.
This is a valid view, especially when you consider that pre-software when you bought a copy of a work it was a physical work and you could modify or manipulate it as you wished. Once bought it belonged to you. Early on the copying devices whether reel to reel, cassette, or VHS were generally included in this and you could do what you wanted with that stuff as long as you bought your copy. If your VHS tape had a problem you could run it through filters or snipe and tape the magnetic film in the VHS and so forth.
The philosophy behind the GPL isn't some religious rant. Its the simple idea that once you have bought it, you own it and should be able to do what you want with it. It only seems like nonsensical religious ranting (and for some it maybe it has become that) because entire generations have grown up indoctrinated in the industry rights oriented world of licensed software.
That is why the GPL has the requirements it does. It isn't so much to pay back the original author or prevent people from making money, it is to assure users have the same right to tinker with and improve the software they have bought (or been given as the case may be) that they would have if they bought anything else.
Those who license under the GPL believe everyone should have this right, so if you want to take advantage of their labor and modify the toy and distribute it to others your only obligation is to extend those same rights to your own users.
You are not distributing the code so you don't have to publish it. How are your competitors going to have this? You do not distribute, you do not publish your own additional code. You can use GPLed code as much as you want. If you want to distribute such software then you have to provide the code to your customers.You said this is not the case.
Wait, so if you write a game, make a digital picture and I start selling it as if it's mine,
that's not stealing?
This is ridiculous if you think it is not.
Slashdot needs Geekcode | Can anyone recommend any good SCIFI? My tastes: Foundation, Startide Rising, CITY, Ringworld,
I somewhat agree, but of course sharing information completely openly wouldn't turn the world into some lawless festering hellhole, which I know wasn't what you meant, just saying. It simply depends on what you want IMO, on where you want to draw the line. "Freedom" typically means "respecting" one another, and thus being punished when you don't, so that everyone can stay "free". Yes, that was a cyclical definition. So, is your definition of freedom respecting the lives of others? OK, how about respecting the speech of others? How about the other's "property"? How about taking pictures or videos of something someone else has made? Totally depends on what you want "freedom" to be. ^^
Promote true freedom - support standards and interoperability.