Slashdot Mirror
Open-source Licensing: BSD or GPL?
BSDForums.org writes "Mark Brewer of Covalent Technologies argues BSD is better for the enterprise. As open source licensing models, both the Berkeley Software Distribution license and the General Public License have advantages and disadvantages. But in the end, the BSD offers more benefits to enterprise customers. Matt Asay of Novell makes the case for GPL. He says, no one open source license is ideal in every circumstance. Different licenses serve different ends. Berkeley Software Distribution-style licenses have been used to govern the development of exceptional open source projects such as Apache. Clearly, BSD has its strengths. However, all things being equal, he prefers the General Public License (GPL ). The GPL is one of the most exciting, innovative capitalist tools ever created. The GPL breaks down walls between vendors and customers while enabling strong competitive differentiation.
Which is a better licensing model for open-source applications: BSD or GPL? What do you think?"
The GPL is one of the most exciting, innovative capitalist tools ever created. The GPL breaks down walls between vendors and customers while enabling strong competitive differentiation.
;-)
Buzz word overload! Take cover! Buzzword overload! Take cover! Buzz...
* Robot's head EXPLODES in a shower of sparks!
Would it kill people to speak in normal sentences instead of Market Speak(TM)? This entire article is just silly. Of course businesses prefer the BSD license. It places fewer restrictions on them, and allows them true ownership of derivitive works. That gives them something to later sell or use as a barganing chip.
Of course many OSS authors prefer the GPL. It forces companies and other users to help pay for development by giving back. The benefit to OSS authors is very clear. The benefit to businesses, however, is still questionable in many circumstances.
In the end it comes down to the usefulness of the software. If a business can't build upon BSD licensed software, they'll go with GPLed software. But if they can help it, they'll just go for the public domain stuff.
Javascript + Nintendo DSi = DSiCade
The GPL license is perfect for developers.
The BSD license is perfect for everybody else.
The GPL motivates development because DEVELOPERS are enticed by the idea that derivatives of their code will REMAIN open, and that their projects will flourish.
If corporate consumers of free SW prefer BSD licensing, then they're free to choose from the tiny subset of free sw that's licensed under BSD. Their demand is NOT going to motivate the creation of significant additional BSD software.
First you say they work to different ends and then ask which is better. Isn't that like comparing swiss cheese to nuclear physics?
I pretend to know more than I really do by mooching off google and wikipedia.
Why not mark the entire post and resulting thread as -1 flamebait now and get it over with? While it's an interesting question and I'm sure there are places where people could have a nice mature and rational discussion about it, /. is just NOT one of those places...
Anyways, as an encore, I think the next posting should be "VI vs. Emacs: Which is the best text editor for your needs?"
It is not logical to expect (IMO) that a company contracting another company is always going to want (or be willing to accept) a GPL style license, so GPL'ing something limits its use in corporate sectors (again IMO).
Now many times if you go and ask the library authors' they'll grant special permission especially in a case like this, but it's a hastle to work with. And you can argue that you should fight for free software all over, but it doesn't make business sense in every case, especially when your company is not in the business of providing support.
Also the LGPL solves this sort of issue to some extent, but I'd say the LGPL is more BSD then GPL, but that's a bit of an overstatement...
The BSD license offers more advantages to companies looking to sell software derived from existing software. They can take BSD-licensed code, do what they wish with it and treat the results as their own proprietary code.
The GPL license offers advantages to end-users long-term. Anyone wanting to take advantage of the starting point GPL'd software offers has to return the favor in the form of their code. Essentially it makes developers let other people take advantage of their work in the same way they took advantage of others' work. It also guarantees that, as an end-user, you're never in a position where you can't get fixes and modifications to the software.
Which one is better for you as the author of the software who has to decide on the license to release it under depends on your goals for the software.
The article submitter should be flayed alive. The /. editor should be drubbed soundly.
Use the GPL if you're going to get upset if someone uses your code commercially without paying you. GPL won't quite prohibit that kind of thing, but it will make most business models involving it impractical.
Use the GPL if you have strong philosophical objections to the basic idea of intellectual property. If, eventually, a sufficiently large portion of code is GPLed, then it might become prohibitively difficult for anyone to make non-GPLed code without re-inventing the wheel. Dream on.
Use the BSD license if you just want your code to be useful to as many people as possible.
How many companies, as opposed to not-for-profit organisations have actually released software as BSD? For a company, *releasing* software as BSD makes no sense. Here, take my work. Oh, Mr Competitor, of course you can use my money and research to help you compete against me. No, you don't have to give me any improvements you make. With the GPL the company is assured of getting any improvements back. It's taking the gamble that while its money could be used to help its competitor if they use the code for anything it has to release *that* as GPL so that it can use it. Also if its competitor makes an improvement it will be able to use that improvement itself. For a company *releasing* software under an open-source license BSD has no real advantages and many disadvantages.
For a company that *consumes* open-source software - and by this - I don't mean using Linux on the desktop but say taking open-source software and using it in their own programs or repackaging it, BSD is obviously superior as they can take as much as they like for free, profit from it and not give anything back.
Personally I think if BSD was the predominant open-source license you won't be seeing nearly as many companies releasing their work as open-source. For for-profit companies, BSD gives all the benefits to the selfish companies and penalises the generous companies. GPL is more fair from a for-profit perspective.
Otherwise you're just doing free work for some software venture capitalist, which is stupid. I mean, if you want to help people, go spend time with sick children or something.
Apparently there are some mods who only read half of the comments.
So I suppose the Apache Foundation should just give up the work they've done? I suppose name-recognition for a popular BSD project isn't enough for you?
If anything, licensing under BSD instead of the GPL is the most selfless act a software developer can make. It means they are coding for the love of coding, not because of a political or philosophical agenda. Is there something wrong with that?
Likewise, is there something wrong with working for Habitat for Humanity, the Peace Corps, and The Hunger Project?
The dynamic linking issue is probably my only real gripe with the GPL. It makes it almost impossible for me to realistically consider using the GPL for any of my code. The LGPL is much easier to work with and still provides almost all of the same benefits as the GPL for me as a developer, and my users get the same basic freedoms from it as they would from the GPL (theoretically, they actually get more), so most of my projects are licensed under the LGPL (or occasionally just the plain ol' zlib license).
On a side note, I recently asked one of the XviD developers about including the XviD codec with a LGPL application I had written. I don't directly use the XviD codec; I use the standard Win32 VFW API to load video clips and play them back. I wanted to include XviD in the installer so that my users would have a quality codec ready to go without having to pay any license fees. The developer stated that because XviD is GPL, all of my code (and any scripts my users wrote, as well) had to be GPL, otherwise I would be violating the GPL. Because of this, I ended up having to include a commercial codec with a less insane license instead.
using namespace slashdot;
troll::post();
(That has be said many, many times on this article)
. . . . is of the subset of companies willing to consider opensourcing their software, very, very few would be willing to BSD license their code, as opposed to GPL licensing it.
At least with the GPL, they 'feel' like no competitor will 'abuse' their property (i.e. take it and not contribute it back).
That should tell you something about why most companies prefer the BSD license. It have very, *very* little to do with code they themselves are releasing.
This doesn't mean that John Q. programmer shouldn't ever use the BSD. But think carefully about what it means when someone says most companies prefer the BSD license.
Microsoft has said they prefer the BSD license. How many BSD licensed Microsoft packages are there?
WhiteWolf666 an exBush supporter. All you new-school,compassionate,save the children Republicans can rot in hell
The GPL: The code is Free and will always remain Free. As a developer if you don't like it, tough, no one cares about the developers Freedom.
The BSDL: The developers are Free to do what they like. The code may not always remain Free.
See? See why we have so many arguments? GPL zealots apply their definition of Free to the BSD and scream "The BSDL isn't Free!". The BSDL zealots apply their definition of Free to the GPL and scream "The GPL isn't Free!"
The GPL & BSDL just have different focuses for their Freedom, that's all.
TROLL
Because:
1) It offers *zero* real protection, *especially* for *small developers* with no legal team to back them up.
2) For people that *are* honest, it causes a hell of a lot of interworking problems.
These are quite simply the facts, regardless of all the religious beliefs that are continously being flaunted above by misguided GPL zealots.
END TROLL
I marked this as a troll because that is how most people will percieve it. Nevertheless it's the truth.
So, in my mind, it creates an unacceptable exposure for anyone who wants to develop software but not adopt the GPL.
So, in your mind, what is so hard to understand about, "don't link with GPL libraries if you don't want to GPL your code?" Static or dynamic, it don't make a whit of difference.
When information is power, privacy is freedom.
y biggest problem with the GPL is the FSF's position that even dynamically linking against a library under GPL is enough to make the resulting code a derivative work (and thus also subject to the GPL).
The FSF doesn't define derived work, that's a legal term from copyright law. Most lawyers are of the opinion that the FSF is being far to liberal and that much more stuff would constitute derived than even they believe (stuff that most programmers would consider "mere aggregation".
It makes a world of difference, since dynamic linking is done by the user of the software via a dynamic linker, not the developer. All the developer has to do at compile time is to adhere to a specific interface. No other code than the developer's own needs to be used to build an executable, thus no other code than the developer's own needs to be distributed should he decide to distribute an executable (although the user must have an appropriate dynamic library installed though.)
The GPL says that this is in violation of the license if the developer's distribution isn't GPL compatible. This prohibits the developer from distributing the dynamic library (since he does not own the copyrights to that) BUT that's all it does.
The GPL can't control the manner of distribution of the developer's code since he owns the copyrights to that code, and it can't be considered a derivative work. If you don't agree, then you are saying that copyright extends to interfaces! That might make SCO happy but probably very few others...
Of course, I was labeled a troll instead of being rebutted when I proposed a scenario such as this on Groklaw...
The intent of the license is completely irrelevent, if you have not agreed to the license. The intent of copyright law is what matters. If dynamic linking causes something to be a derivative work of a library, then you start worrying about the library's license. If dynamic linking does not cause something to be a derivative work, then it doesn't matter if the library is GPLed or LGPLed or Microsoft Windows EULA or anything else, because you're not licensing the library. The terms of the license do not matter.
A license, regardless of its intent of copyright law. It cannot define the conditions under which the license's terms must be obeyed -- it assumes that those conditions have already happened. If that assumption is violated, then the license is irrelevant and its terms do not apply.
As copyright owner of this comment, I authorize everyone to defeat any technological measure which limits access to it.
Why do people insist on trying to find technical workarounds to ethical and legal problems. The technical details of how your code interfaces to GPLed code does not matter when it comes to determining whether it is a derivative work.
I like it, but it's not quite accurate.
The GPL is about making GPL'd software better. GPL'd code is not useful to developers using any of the other FOSS licenses, only to people using the GPL.
As far as the GPL is concerned, The Apache Group and Microsoft are both disqualified for cooperation.
The GPL exists to encourage the use of the GPL. The BSDL exists to encourage the creation of quality software, regardless of license.
They're not designed for the same purpose. The GPL is designed to exert pressure on other people to behave in a certain way (mainly, to contribute back their changes) and to grant them fewer rights if they do not. The BSD license was designed to allow the code to be used by just about anyone for just about any purpose, so it grants its freedoms a bit more freely.
If you are implementing something like a networking protocol or file format reference implementation, then your most important goal is widespread adoption, and in that case you need to go with a BSD-style license (or just plain public domain). This allows vendors to roll your implementation into their proprietary products.
For an end-user application, such as a music player, that concern is less important, and so other considerations become relevant. At that point you ask yourself, "Am I comfortable with allowing FooCorp to incorporate my music player into FooMedia Center and distribute it under a proprietary license?" If you are comfortable with that, you can go with a BSD-style license, but if not, you will want to opt for a more restrictive license, such as the GPL (or LGPL, if you want to allow non-GPLed code to link against yours).
Ask yourself: if Microsoft or Apple incorporates your code into some portion of their operating system, do you rejoice because it's seeing widespread adoption, or do you get angry because they're stealing your work? In the former case, you want the BSD license, or something very like it; in the latter case, the GPL is more your cup of tea.
Also for a smaller project you may ask yourself this: if other people contribute patches, and then you go get a new job, do you want to ensure that you have the freedom to roll this code (that is mostly yours but contains others' patches) into one of your new employer's proprietary products? If you want to leave yourself that option, you consider the BSD license; if you would prefer, OTOH, that the code you've worked on *not* be rolled into a future employer's proprietary products, you would probably be happier with the GPL or perhaps LGPL (again, depending on how you feel about linking).
Cut that out, or I will ship you to Norilsk in a box.
The vast majority of enterprise level corporations, and smaller companies, don't produce software that is distributed outside of the company. Below enterprise level companies an even larger percentage doesn't distribute software.
For these companies the license doesn't matter. Both licenses are equally free on the end-user. The licenses differ in what developers have to do if they distribute their works outside of a corporation.
For a corporation that does distribute software, wanting to build a standard the GPL would seem better to me. Under BSD a competitor can take your work, add to it and distribute it without releasing code -- competitive advantage to the competitor. Under GPL any changes must be available, they can't keep secret their modifications. Level playing field.
Freedom is not being able to do whatever you want. I cannot go and kill someone, but I have no doubt that the society in which you are not allowed to murder is the freer society. There is both "freedom to" and "freedom from". That said, BSD, LGPL, and GPL all have their place. All my work has been BSD so far, but I could see myself using LGPL (or maybe even GPL) in some cases.
The BSD licence focuses on freedom for the developer. Do what you want with it -- change it, sell it, close source it.. Whatever. Once you have the source code, (if it's still free) you can do whatever you want with it.
The GPL focuses on freedom for the source code. Do whatever you want -- change it, use it sell it, whatever -- as long as people continue to have access to the source.
The problem with the GPL is that some companies may be unwilling to use GPL code in a product if it meant that they have to make their changes publicly available.
The problem with the BSD license is that, for any company that faces real competition, releasing code changes is potentially a zero-sum game. If your competition takes your BSD code, improves it and closes off the changes, they gain from your work, and you lose.
In other word, each license has a potential cost for businesses. For GPL, the cost comes when you choose to use it. For BSD, the cost comes when you look at releasing your changes back to the community.
Given these associated costs, I'm not at all surprised to see that companies like SUN are willing to use BSD code all over their own products, but unwilling to contribute back to the community -- Contribution is where BSD costs a company. Of course, this refusal to contribute back has a cost for companies, as well. It places an intrinsic limit on the vibrancy of the community that created the product that you're so happy to use. The BSD license feeds into the environment of greed, and suffers from the costs of that approach.. The irony is that it depends on a commitment to contribution for the BSD codebase to continue growing.
This is where I see that companies like IBM prefer the GPL. Using the GPL means that you can contribute back to the community that gave you your product without having to worry about your changes being hijacked by your competition. Any changes that your competition make are required to be returned to you. The GPL enforces a share-alike attitude among it's redistributors and thus allows a company to justify contributing code back into the community. This creates an environment where the code, if it is of any use to the commercial community, it is highly likely to increase in an almost viral pattern anybody who likes it enough to use it tends to contribute to it's growth (either directly or indirectly).
This, for me, is why I'm willing to contribute to BSD code, but prefer GPL licenses. The BSD license needs a culture of contribution, but the GPL creates a culture of contribution.
Free Software: Like love, it grows best when given away.
I understand that some of you may only have heard of the open source movement. I'm grateful that you would consider using the GPL for your projects. However, the GNU General Public License (or GPL) predates the open source movement by many years by the founder of a movement with different goals than the open source movement. Therefore it is not fair or accurate to credit the GPL as an "open source license" merely because the Open Source Initiative (which started the open source movement) placed it on a list of approved licenses.
The GPL was written by Richard Stallman, most notably. Version 1 of the GPL was released in January 1989, and version 2 (the current version) in 1991. So, two major releases of what has come to be the most important and popular free software license were released well before the Open Source Initiative was founded in February 1998. The OSI has yet to write a license that compares with the popularity or strength of the GPL.
The GPL speaks repeatedly about software freedom, not "open" anything, and for very good reasons. First, the term "open source" didn't exist when the two revisions of the GPL were written. But even if the OSI existed, the open source movement doesn't want to frame any issue in terms of software freedom because it gets in the way of addressing businesses, their chief audience. Talking about software freedom means talking about something beneficial to users, not addressing more efficient means of connecting cheap programming labor with businesses. Philosophically and historically, the FSF and OSI are not the same, nor are the free software and open source movements. Stallman and Eben Moglen, chief counsel for the FSF, confirm this in every speech they give and virtually every essay they write. The Free Software Foundation has published an essay describing the differences between the two movements and why they see the free software movement as better. To this list of differences I'd add that free software guarantees private derivatives, unlike the open source definition.
The upcoming GPL (version 3) in this regard because it will be the first version of the GPL where anyone from the OSI may have editorial say in. The final word (and framing of the issues surrounding the GPLv3) still comes down to Stallman and Eben Moglen.
Thus, with all of this history, I think it is fair to call the GPL a free software license, not an open source license. The GPL existed well before and independantly of anything to do with the open source movement and does not embody the values of the open source movement. I encourage you all to stop misleading people into giving the OSI and the open source movement an undeserved primacy.
Digital Citizen
No one is compelling you to do anything. If you chose to build on a GPLed work, you have chosen to provide people your code upon request when you distribute it (quite selfless). GPL doesn't force anyone to make that choice.
Any social system have a form of property, if i think in socialism i also think in colective property, like GNU and GPL software.
But how is GPL software "collective property"? There's nothing "collective" about the ownership rights involved in the GPL. If I write a piece of software, and license it to Al under the GPL, I still own it; meanwhile, Al owns it *too*. We don't own it "jointly" or "collectively", we *each* own it, and we can *each* do what we want with it.
Downmodding is the refuge of the weak. Don't downmod, make a better argument!
That's exactly why the LGPL exists.
You shouldn't be copying from the headers anyways. You should be #include-ing them.
It's really not that big of a deal to make most programs dynamically linked... it's standard industry practice.
That the user can replace some libraries is actually a good thing... for example, the SDL shipped with Neverwinter Nights does not work with some recent versions of nvidia-glx, but newer versions of SDL do, so I just replaced the SDL in NWN with a symlink to my more recent SDL library. If I couldn't do this, I wouldn't be able to run the program, and I wouldn't have bought the expansion packs.
Can you cite any court precedent or statute backing up this interpretation of what constitutes a derived work? It seems rather insane to me, especially the part about a work's derivedness changing based on the appearance of unrelated third party software (is it derived if I think such a thing will be written, or if I intend to write it in the future? If you sue me and win before the 3rd party implementation is written, can I sue once it is written for a reclamation of any damages I paid to you, since now it's not derived, and thus it was legal for me to have made and distributed it? If there is a 3rd party implementation, and I write a client that uses the interface in question, and you buy the copyright to all 3rd party implementations, does it magically become derived from all of them? What if you merely form an agreement with all of the copyright holders of the 3rd party implementations to deny me derived work rights? What if there was a BSD-licensed implementation when I wrote my client, but it got lost and the only remaining implementation is yours?), or my web browser being a derived work of your webserver because you changed it to require "GET2" instead of "GET" and I changed my browser to match without retaining the ability to send out the standard "GET" or changing a second server to accept "GET2" (but wait, wouldn't making such a change cause the second server to be derived from the first?).