Feature:GPL vs BSD

Joe Drew wrote in to give us his perspective on a debate that is quite the rage these days: the BSD License vs the GPL. He has written up a summary of why he prefers the GPL, and I think it might be worth a read- especially if you have been wondering about this stuff (and according to my INBOX, many of you are).

The following was written by Slashdot reader Joe Drew

The GPL vs the BSD License: A GPL advocate's perspective

Recently, there has been a lot of anti-GPL sentiment in the BSD camps. A cynic would say that they are simply jealous over the GPL's (and Linux') success; however, with a careful examination of reality one notices that the BSD license is no less, perhaps more successful than the GPL, and the BSD variants are thriving in their own niches. So why the anti-GPL sentiment? Personally, I believe it's two things.

1. BSD advocates are maybe just a little, tiny bit bitter over the fact that Linux is perceived to be more successful than BSD. Everyone with his head screwed on straight knows that neither of these two factions are going away, but nonetheless, there may be some resentment there. By creating awareness of their OSen, they can draw attention to it.
2. Some BSD advocates mistake the anti-proprietary slant to the GPL as pro-communist or anti-capitalist, both of which are blatantly foolish and incorrect.

The GPL exists because Richard Stallman, rms, wanted to ensure the freedom of software forever. Free Software, of all its types, thrived then and thrives now; however, the GPL is one of the only licenses which guarantees that Free Software cannot become non-Free. This doesn't mean that money can't exchange hands over Free Software, only that it can't become proprietary.

When using the BSD license, your software is just as Free as when you use the GPL. However, a company can take your code, incorporate it into its own proprietary product, and (depending on the type of BSD license, with or without advertising clause) you can receive no compensation for your work, perhaps not even credit. If that's exactly what you want, then the BSD license is for you. However, it seems just a little bit dangerous for a lot of Free Software authors.

This isn't possible with the GPL. It's always there, blatantly in your face, telling you ``You may not use this code in proprietary ventures.'' If a company takes your work, repackages it and sells the repackaging and service for it, your code is still available. It isn't legally permissible for them to take your code, incorporate it into another product and sell that product.

The BSD license is a fine license. It does exactly what it's meant to do, which is get the software out there. For a lot of Free Software authors, that's exactly what they want. However, for some people, that's not good enough -- they want to give everyone the freedom to do with the code what they will, but they don't want to give people the right to make the code proprietary.

The GPL is very popular, and very effective, because it protects people's Free Software, while still allowing them the freedom to do with it essentially whatever they want. Many people make a living selling and creating Free Software; this number will only increase as its benefits become more publicised and well-known.

The bottom line is, the GPL is not anti-commercial or anti- capitalistic; it is only anti-proprietary. The BSD license, on the other hand, is very unrestrictive, and allows proprietary knockoffs. Which you choose depends on what you need and what you value. There's nothing more to it than that.

Comments

The flip side

[Anonymous Coward]

The flip side of your argument is that the GPL is less free than the BSD license. The BSD license retains the freedom to incorporate the code into proprietary products, and that's a freedom which the GPL does not allow.

The *real* disagreement between the two camps is over whether that's a good thing or a bad thing.

Re:The flip side

[Zack]

The orginal author of the GPLed code still has full copyright of it, correct? And they can change the copyright on any subsequent version (i.e. they can make it proprietary in the next version but can't stop people from distrubiting the GPLed code.)

As such, any company that really wants to use GPLed code in a proprietary product would have to get the permission of the author, who could in turn demans payment, royalties, credit, or something else.

It seems to me like the GPL protects the interests of the coder as well as the general public.

Re:The flip side

[gavinhall]

Posted by konrad72:

Well, but using this so called "freedom to incorporate the code into proprietary products" takes away exactly all freedom the GPL tries to preserve. It's a one time freedom, usable only by the one person or company creating a proprietary product. Once this is done, all freedom will evaporate. So comparing BSD and GPL it seems obious to me that only GPL can /guarantee/ that freedom will stay.

Re:The flip side

[ethereal]

You are correct, there is no harm to the existing codebase. However, the GPL isn't really as oriented towards preventing proprietary add-ons themselves as it is with encouraging improvements to the code base to be non-proprietary. It sounds like this is splitting hairs, but it makes sense when considered in terms of the goals of the FSF and the GPL: to encourage better software through the availability of source code.

A proprietary addition to a BSD-licensed project doesn't harm the base code, but it doesn't add anything to that code base either, because the source code for the additions is not available. In that case, the only winners are the company who can now sell the enhanced product. A GPL'd addition to a GPL-licensed project actually adds more code to the code base, which can lead to better software for everyone since anyone can use the additions in their own projects. Of course, no one individual or company can derive all the benefit from the improvements, because anyone can try to sell this code. There's a trade-off between the good of those who write additions to an existing codebase, and the good of the software community as a whole. So it doesn't harm the existing codebase to write closed-source additions, but a lot more is gained (according to the FSF, at least) by writing open source additions.

Re:The flip side

[ethereal]

Well, technically you can enhance GPL'd code all you want as long as you don't distribute those changes. This is specifically stated in the GPL, so the GPL doesn't enslave your new code at all. The GPL does make certain requirements upon your distribution of GPL'd software, which makes sense because the authors don't want just anybody changing the license of their software and redistributing it. So really the only problem you have is how to keep your additions proprietary while distributing them along with and integrating them into GPL'd software. This doesn't seem too enslaving to me - you can do what you want with your code, as long as the original GPL'd code remains free as it was licensed to you. Of course, it may be very difficult to distribute your proprietary software in this manner (while keeping it proprietary), but RMS never promised you a rose garden :)

The software is free, not the people.

[Anonymous Coward]

I was all set to write a long essay in response, but most of the readers here would probably just appreciate a summary:

The GPL license is conducive to liberating software.

The BSD license is conducive to liberating people.

With the GPL license, the software maintains more of the freedom than the programmers who work on it.

With the BSD licenses, the programmers maintain more of the freedom with what they are allowed to do with derivative code.

Re:I have a question!

[HoserHead]

You can't technically release BSD code under the GPL. You can, however, incorporate BSD code into a GPL'd project, because there is nothing in the BSD license which says you can't put more restrictions on it, and the BSD license without the advertising clause is 'compatible' with the GPL in that it doesn't place any other restrictions on the source code. Such is the case with some drivers and bits in the Linux kernel; parts of it are under the BSD license, but the kernel as a whole is distributed under the GPL.

Re:Au contraire

[HoserHead]

I'm the author of this piece.

I sort of wish Rob had told me he was going to post it :) ; I would have reviewed it and changed this. I meant it to say that it cannot be incorporated into a proprietary product and sold - and I am very aware of the difference - but unfortunately I didn't write it that way in its current incarnation.

In a perfect world, BSD would be the perfect...

[Codifex Maximus]

license. However, we don't live in a perfect world so... the guarantees of freedom and source code availability of the GPL are a neccessity.

I respect the ideals and the skill of the BSD people but they are being robbed blind by the corporate element! The BSD folks strive to have complete freedom and the very best code! They will never have the very best code because everyone else will have it too! This situation is probably their aim and if it is... it's working. They are selflessly advancing the state of the art. I'm sure that Bill and Steve appreciate it!

I vote for the GPL because the GPL protected codebase becomes a living thing that constantly improves. It survives the demise of it's creators and is not dependant on any one entity for it's livelihood.

The BSD license provides for a public good that is consumable; the GPL license provides for a public good that is durable.

Re:In a perfect world, BSD would be the perfect...

[Codifex Maximus]

>Then you should respect their wishes to allow
>their code to thrive whenever and wherever it
>may.

I do. The BSD style freedom is closer to the utopian idea of freedom than the GPL is. However, we don't live in a utopian world. (The theme of my original post.)

>The point is, the code base that you put out
>under the BSD license cannot be taken away from
>you or the rest of the community.

Not taken away but proprietized and closed up under a DIFFERENT license.

>It cannot be modified and re-released by someone
>else who claims to have written the code in the
>first place.

It can't be modified and released under the BSD license with credits given to somebody else... no.

>It fosters commonality in code bases, making it
>easier to track and fix bugs if someone keeps
>their code close to the original.

BSD does foster commonality in codebases - true. But, those codebases tend to diverge over time contributing to the current state of the UNIX world. Can you deny this?

>>I vote for the GPL because the GPL protected
>>codebase becomes a living thing that constantly
>>improves. It survives the demise of it's
>>creators and is not dependant on any one entity
>>for it's livelihood.

>And how, pray tell, is BSD any different? Do not
>the free BSD operating systems and maintainers
>of packages under the BSD license fix bugs and
>support their code? Have there not been changes
>in maintainership of BSD-licensed code in the
>public? How does code under the BSD license not
>stand up to this litmus test of yours?

You have told me how BSD is different or not. Evidently, my 'litmus test' was wrong.

>>The BSD license provides for a public good that
>>is consumable; the GPL license provides for a
>>public good that is durable.

>Again, I fail to see how the GPL ensures this
>when the BSD license doesn't.

Look at it from the corporate point of view. They see things as goods that are consumable or nonconsumable assets that can be used during the course of business. The BSD source code is such a good - it has value even though the cost of procurement was minimal. The good is incorporated into a VALUE-ADDED product that is sold for a profit. The corporation makes money by adding VALUE to a good and selling it for a profit. If the value is percieved by the customer then the purchase will be made. The enhancements made to the original good will not be released back due to the fact that the enhancements are the intellectual property of the corporation and the primary source of profit in the sale of the enhanced good.

Hence, BSD becomes a free R&D lab for the proprietary operating systems of the world. The companies take the code, proprietize it and laugh all the way to the bank.

You, however, still have your much vaunted rights to the original code.

>Besides, prove in a court of law that I've
>snitched some piece of code from a GPLed
>package and incorporated it into my own
>commercial product. Go on, I dare you.

A very valid point. If there are proprietary systems that use GPL code that are being distributed outside of the entity that modified the code then violations of the GPL are alleged to have occurred. Proving the point is difficult but not impossible. A team member could spill the beans and implicate the business entity of abusing GPL code. Then there would be litigation. As you know, litigation is expensive.

>If I use a BSD-licensed product for, say,
>reading in a file of some specific format,
>then I've helped to make that format a standard,
>and increased the interoperability of various
>programs and modules because I've used the code.

>How does that make you suffer?

BSD does not make me suffer. Proprietary enhancements to open standards, designed to 'lock-in' a userbase, make me suffer.

Re:In a perfect world, BSD would be the perfect...

[coreybrenner]

> Not taken away but proprietized and closed up under a DIFFERENT license.

This may well be true, but one would have to care, I guess. I am going to release a little code module under the BSD license pretty soon because it is easily integrated into pretty much any Unix system, and can provide functionality for very little cost. It's a fixed-chunk-size memory allocation wrapper for malloc(), if you care.

I'll release this code for a couple of reasons:
1) I think it can be useful.
2) I'd like to see it ported, and to see what others in the free software realm can do with it, how it can be improved, and what I can learn from others in the improvement of my software.
3) I think it'd be absolutely awesome if, some day, my falloc() function became a part of some standard (it's an ego thing).

> It can't be modified and released under the BSD license with credits given to somebody else... no.

And that's the only thing I'd give a rat's rear about. What commercial vendors do means very little to me. As long as I get paid a substantial amount of money for the work I do, what I do in my free time and towards the ends of my own little forays into researching things I'm curious about are my own business. If I want to release that code to the public, then so be it.

If some hot-shot commercial vendor wants to take that code and incorporate it into their libc, then so be it. If I ever see falloc() on, say, an HPUX box as part of the C library, I'll just grin. If someone rewrites part of my code, points out an error, ports it to a 64bit platform, or whatever and remits the patch to me, then so much the better. I can see what they've done and learn. That's all I care about.

> Look at it from the corporate point of view. They see things as goods that are consumable or
> nonconsumable assets that can be used during the course of business. The BSD source code is
> such a good - it has value even though the cost of procurement was minimal.

By this logic, then, the Linux source code has absolutely no value? Certainly to a corporation this comes close to the mark, forcing them to yet again reinvent the wheel, or to have to have more staff so that 'infected' people can look at some GPL code and write up a specification, what the code does, and hand that over to a 'clean' person and have that person implement the specification. Let's say, for the sake of argument, that I want to use some of Linux' memory management ideas for the x86 in some wacko proprietary operating system of my own design, for whatever purpose - maybe something top secret and military or something. I have to hire at least one more person to actually get those memory hacks into my code base, or it becomes infected and my whole ball of wax melts. So, the GPL forces reinvention and code non-reuse.

> The enhancements made to the original good will not be released back due to the fact that the
> enhancements are the intellectual property of the corporation and the primary source of profit
> in the sale of the enhanced good.

Does that, then, in any way, harm the original source base? Do I care whether some company releases their enhancements back into the original pool, if I'm working toward a different goal? Not really. If they do, and I find their changes useful, more the better. If they don't, well, they can simply maintain their new and improved mess themselves without any assistance from me. I'd be more likely to give companies or, rather, product managers and engineers the benefit of the doubt. I'd prefer to think that they're decently moral enough to do the Right Thing[tm]. If they don't, well, they'll burn in Hell. Do I care? Not in the slightest.

> Hence, BSD becomes a free R&D lab for the proprietary operating systems of the world.

Correct-a-mundo. This was its original intent, anyway. That that hasn't changed in the slightest, and that the BSD code base thrives in spite of it is a testament to the efficacy of that model. Enhancements are made every day to the active code bases of the various BSD projects, by private individuals and by corporate users working on derivative projects. It works. Really.

> The companies take the code, proprietize it and laugh all the way to the bank.

And I laugh at them. I don't know if they're using my code in a proprietary product, just as you don't know if someone is using your GPLed code in a proprietary product. The difference is, I guess, that I don't care a whit. Let them use it... heck, maybe they'll decide I'm da shiznit for writing such a useful package and hire me for an exorbitant amount of money. :)

> You, however, still have your much vaunted rights to the original code.

Which, because I am a completely arrogant and egocentric bastard, is all that I require.

> BSD does not make me suffer. Proprietary enhancements to open standards, designed to 'lock-
> in' a userbase, make me suffer.

Viral licenses designed to 'lock-out' an entire segment of a population (corporate users and developers) make me suffer. I guess it's a Mexican stand-off. A veritable Catch-22.

--Corey

Can't incorporate code into another product?

[Pretender]

If a company takes your work, repackages it and sells the repackaging and service for it, your code is still available. It isn't legally permissible for them to take your code, incorporate it into another product and sell that product.

Stricly speaking, I thought they could do just that - as long as they released the new code as Free Software in the same sense. As the author states elsewhere, it keeps it from becoming their intellectual property in any real sense.

Not meaning to nitpick, just hoping to clear up some confusion.

Charlie

FreeBSD, OpenBSD, NetBSD, MicrosoftBSD...

[kevin lyda]

I originally didn't like linux because I first started with BSD based systems (SunOS). But linux eventually won out because of more drivers, some more BSDish userland tools, and the fact that it's a level playing field. The last part is due to the license.

Joe Schmoe and Company X are on equal ground with the GPL. Anyone makes a change, everyone gets to see it. No "Embrace and Extend" for Linux and the GNU utils.

Contrast this with past experience with X and BSD. The Open Group almost took over a decades worth of patches and contributions and restricted their availability. They stopped, but they could do it again. Sun made changes to the BSD base of SunOS - the BSD community didn't get those changes back. BSDI has done the same, though they're pretty good about feeding back patches from what I hear.

The GPL makes people be kind, benevolant dictators. RedHat's recent IPO said they needed to keep the good will of their users/developers - when has any company ever said that in their IPO? The BSD License just assumes people will be good citizens of developerland. Don't get me wrong, I like that assumption more, but experience shows the GPL is needed for the morally challenged.

As for Microsoft BSD, it's quite possible. It's very possible. And they can easily make it incompatible with the other *BSD's and Linux. And if they get their way wrt the US Universal Product Code, they can even stop people from reverse engineering the results. So they'll be able to build off of the ideas free software developers create without having to share those ideas back. And we'll be back to reinventing the wheel all over again.

Re:Why do we need licenses at all?

[jtn]

GPL encourages reinvention of the wheel, not BSDL. GPL code is off-limits to a developer creating a product, thus forcing him to possibly reinvent the wheel when he could have simply used the GPL'd code and not necessarily given away *HIS* code. You have no right to exercise rights over *HIS* code.

Re:Can someone help me here?

[fishbowl]

The original author, who is the copy(right|left)
holder, can do whatever he pleases, including
putting it into a proprietary system. Nobody ELSE
can do that, and it's an important distinction.

GPL is all about redistribution.

The original author can release the same code under multiple licenses.

Righteousness of one license vs another.

[Duke of URL]

Here is an interesting quote from Pedro F. Giffuni, at deamonnews


"I arrived, however, to two important conclusions:


1.the GNU Public License will not save the world,
2.there shouldn't be a universal license; different situations require different licenses."

Both Joe Drew and Pedro F. Giffuni are very biased towards their favorite license in their discussions.
I think it is very shortsighted to think that all software should be licensed under one system, whether its GPL, or BSD.
Authors have the freedom to choose whatever suits their needs or desires, as long as they have a clear idea of what they want for their code's future. How can GPL or BSD be better and more "right" than the other when they both have very different purposes?

check it out

[cody]

There's a pretty good article discussing some of the short-comings of GPL in this month's daemonnews from the view of *BSDers.

It seems to me like the main difference between the two licenses is that one gives you enough freedom to screw yourself over, while one tries to protect you from that, even if it seems like it is infringing a bit on the freedom you'd want as a developer. It seems like that's the source of a lot of anti-GPL angst.

Re:"Shroud" utilities

[IntlHarvester]

Couldn't Microsoft ship a GPL XFS as an installable file system for WinNT? Of course they would have to ship the source code, but they already do that for things like Perl.(Perhaps I am confused on the GPL and what it means to 'link' to GPLed code.)

Anyways, I'm not sure if XFS has been GPLed. It could be another licence.
--

Speaking as one who prefers the GPL . . .

[Venomous Louse]

. . . it seems unfair to frame the debate in GPL terms, from the GPL point of view, and I think the essay above drifts off in that direction a bit. Even if it were perfect, though, I really can't see how it could result in anything but yet another moronic flamewar.

So why bother? As the man says: Choose your favorite. I know it's heretical to say this on Slashdot, but choice is a good thing. Being able to choose between GNOME and KDE is a good thing; being able to choose between BSD and Lignux (or between Linux and Lignux, for that matter :) is a good thing -- and to hell with all the zealots who preach otherwise.


"Once a solution is found, a compatibility problem becomes indescribably boring because it has only... practical importance"

Promulgating Code vs. Promulgating Standards

[cjs]

Well, as usual, most folks appear to have missed one of the key points that makes the BSD license do so much good for the world. The BSD license, by allowing people to use its code in commerical products, promotes commercial products following open standards.

The classic example is TCP/IP. There are a lot of commercial products out there using the Berkeley TCP/IP stack, and one of the big reasons for that is that it's cheaper than developing their own protocol stack or even buying one. The value we see from this is the network effect; that a device communicates using the Berkeley TCP/IP stack rather than Novell's IPX stack or Microsoft's networking stack benefits all of us, because we can much more easily communicate with it (even, perhaps, in ways that the author did not intend).

Open standards are even more important to freedom for computer users than open source. (Having source code is nice, but it's not much good if it doesn't permit you to interoperate with other platforms out there. Linux is popular because it talks to other computers.) Therefore, I'd say that the Berkeley license has done more than any other licence to bring us to the state today where we have a lot of freedom in our computing choices.

cjs

Too bad they don't come close to the lGPL.....

[Rahga]

You see, I believe one of the best liscences out there is the "lesser" GPL, which was completely ommited in this comparison. The lGPL gives ALL software writers freedom to integrate libraries and programs into proprietary code, but those lGPL'd libraries and programs must still be freely availiable from the software writers in source code form. In other words, both proprietary-nonGPL'd software and free software benefit. Free software like Gtk+ can gain much greater support, and as more proprietary software houses jump onto the linux bandwagon, they will have things to add to and improve in Gtk+ itself.
Straight GPL has always beeen to restrictive in this area. GPL'd (not lGPL) libraries and programs can not be used IN ANY WAY in proprietary software. The GPL is for the advancement of "free" software, but only for "free" software authors. If it can't be used to help everyone, including evil proprietary coders ;), it seems to me that the GPL actually is more geared to "free beer" rather than "freedom".
Isn't it time we re-name the "lesser General Public License" :)?

Re:well..

[ethereal]

There's more to freedom than openness, though. This is the whole Open Source thing: is it enough to be able to see the code, or do we also need the rights to modify the code, distribute modifications, and incorporate it into other projects (other free projects, if GPL'd; other closed projects if BSD licensed).

Re:Why do we need licenses at all?

[ethereal]

GPL'd code isn't off-limits if you are creating a product. Plenty of people create products with GPL'd code - RedHat, for example. Now if it isn't a GPL'd product that you are creating, then you may have some problems.

Your hypothetical developer doesn't need to reinvent the wheel, as long as he is willing to help out other developers by making his code GPL'd the same way that those developers helped him out originally. But this doesn't force that developer to do anything, it just allows them the choice: spend time reinventing the wheel, or else use GPL'd code and contribute a little back to the GPL code base which you are graciously allowed to use by its authors.

This way, the GPL will prevent the reinventing of whatever your developer is working on - since he has to GPL in order to use other GPL'd code (saving him time), later on someone else can use his code (saving them time). Net result: increased code reuse, faster cycle time, and code quality improves more quickly, which is what RMS and the Free Software Foundation wanted in the first place.

Slashdot Poll: who's coerced to GPL?

[ethereal]

Who is being coerced here? I don't see any grumbling over on linux-kernel, or on freshmeat, or any place else where GPL'd software is being created. These people don't seem to be chafing, they seem to be happy to be writing GPL'd code. And there are plenty of projects which aren't GPL'd whose participants aren't complaining. Nobody is coercing them to write GPL'd code either, and they are happy.

The only people that seem to be grumbling are folks who want to use GPL'd code in non-GPL'd projects. I'm sorry if those folks don't like their alternatives, but the GPL doesn't come no-strings-attached. The authors of GPL'd code have specified the licensing terms of their code, and if you don't want to use that license, you certainly have alternatives. You may not have other zero-cost alternatives; RMS never promised you a rose garden. If the GPL'd code that you want to use is so well done that it is a difficult decision not to use it, then perhaps there is more merit to the GPL approach than you are allowing yourself to consider.

You are assuming that someone who writes some code and "gives it away to the world" is somehow more moral because they chose to contribute their code without being asked and without asking for anything in return. In other words they contributed to a charity - they saved other people time and money out of the goodness of their heart. Good for them, but the goal of the GPL is not to encourage charity but to encourage higher quality software with available and reuseable source code. The author of GPL'd code is also providing their source code out of the goodness of their heart (after all, they didn't have to GPL) and they may not receive anything back at all either. But that author knows that their code will stay free and will be provided to anyone who receives software which includes it. In that way, they have given much more to the end user than your developer, because everyone who receives the software must be given the code and will be able to learn from it and improve it. Authors of GPL'd code are making a free moral choice the same as your developer, but since they feel that the GPL reflects their values, they have chosen to GPL their code.

Re:well..

[ethereal]

I meant "need" in the sense of "what is necessary in order to use this code for my own project." In that case you do require certain rights in order to use someone else's code, otherwise you are committing a copyright violation. Of course there isn't a need to use other people's code the same way that we have a need for food and water.

I don't want others to use my code unless it is under the terms under which the code was licensed to them. Likewise, I certainly don't want to use someone else's code unless it is under the terms under which their code was licensed for my use. If I don't have the rights under their license to modify their code, use it in my project, and distribute it, then I guess I can't use that code. Note that this isn't the same as using their code in any way I want - for example, depending on their choice of license I can't change the copyright information, the license, the list of contributors, etc.

I doubt that I'm going to be able to change your mind since you refer to "enslaved projects", but here goes. Licensing your project with the GPL means that you believe in the values that the FSF espouses. These include availability and reusability of source code, higher quality source code (because it's available and reusable), and more GPL'd code. It's this last part that people refer to as "enslaved". The FSF (of which I am not a member, by the way) believes in the GPL enough that they set up the GPL to encourage more GPL'd code. Whether you like the GPL or not seems mostly to depend on whether you think the ends of the GPL justify the means of the GPL. If you don't agree with that, then I suppose the GPL is not for you.

Re:Why do we need licenses at all?

[ethereal]

Access to the original P cannot be restricted - you are correct. The whole BSD/GPL debate really comes down to who gets the benefit of the changes made from P->P+.

In the BSD world, the author of the + section can distribute both P and + together, without source code, and only that author receives the benefit of the + changes. Everybody else has to reinvent the wheel if they wanted to get P+ code and didn't want to get the + from the + author.

In the GPL world, the author of the + section must distribute the original P with source code if they distribute it at all, and if the + code incorporates code from P, then they must distribute the + source code as well. Then everyone can include the + code in their GPL'd projects, which is a benefit for them. Of course, the author may not make as much money (if any) distributing a GPL'd P+ as they would have under the BSD license.

The GPL has a very specific view of what is good for the software world: software distributed with GPL'd source code. Software distributed with GPL'd source code leads to more of the same, which was the FSF's goal. Of course, if you don't like this goal (if you prefer proprietary software or, as another poster pointed out, other free software licenses) then you aren't going to like the GPL or its goals.

Too biased

[GeneralTao]

I'm a GPL partisan myself, but I think that when someone sets out to write an article, they should decide whether they are going to examine both sides of the argument or just advocate one side.

This article is GPL advocacy, not a genuine look at "both sides".

Though it's true that the BSD license allows code written freely to become proprietary, history has shown that companies that do take advantage of the BSD license have a tendency to give back to the community even though it is not compulsory.

The BSDites argue that the GPL's giant "no-no" clause regarding proprietary rights scares companies off. You know what? They are right. Although we've seen alot of free software emerge lately from the corporate world, almost all of the contributors have opted OUT of the GPL.

I think that both licenses have their place, and ultimately I think you'll find GPL'ed software running somewhere below BSD'ed software as a common support infrastructure. The spiffy "add-ons" and extras may be open sourced, but I don't think the corporate world is ready to accept relinquishing the rights to their intellectual property.

Calm down :-)

[Stephen Williams]

How many times is /. going to promote this flame thread by featuring all these GPL biased articles?....this is the second time I have seen this same phenominon and not once have I seen a comment for the other side

Here's a link to a Slashdot story published last month, about a pro-BSD article. I think this answers your point.

http://slashdot.org/articles/99/05/13/1317239.shtm l

Not even close

[mrbnsn]

"but they don't want to give people the right to
make the code proprietary."

This is the problem BSD'ers have with the GPL: the overwrought drama over the possibility that someone, somewhere might hide some code.

Most BSD'ers support free code, and they have full confidence in the relative merits of free code. What they don't have is the compulsion to coerce others into involuntary compliance with this view.

If people take free code and turn it proprietary, then they automatically suffer all the increased costs and headaches associated with developing, debugging, and maintaining a closed source tree. That's their karma. BSD'ers are willing to let it go at that, and not make a religious crusade out of the issue.

If a certain small niche gets served by a proprietary solution, that's fine too. But overall, the fact is that the cards are stacked against largescale exploitation of BSD code. People will figure that out eventually, and in the meantime, there's no point in alienating present and future allies in a fit of ideological intransigence.

GPL vs. BSD

[cmc]

The BSD is a very concise and free license that allows the licenser to allow the source code to be free and also be availible to companies provided they follow the following conditions:


1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.


The BSD license is also much, much less complicated:


$ wc -l bsd-style-copyright
27 bsd-style-copyright
$ wc -l /usr/src/gnu/COPYING
339 /usr/src/gnu/COPYING


The BSD license has far fewer catches and companies that are interested in being able to profit off of their product will be happily able to integrate that into their source code provided the integration and distribution goes under the above conditions.

There are a few `mistakes' that have gotten out somehow that the BSD license is not what it is. Here they are:

• The BSD license allows a company to make a small change to the code and say they wrote it.
  
  This is not true. The original author is the one who gets the credit for it, not the person to make the last change.
  
  
• The BSD license is less free than the GPL.
  
  The BSD license allows for distribution with less catches and it allows the licenser (usually the author) to decide whether or not he or she wants to distribute the source code.

Hopefully this clears up some of the misunderstandings that people on the GPL side may be having.

The GPL has never been about free software

[Tom Christiansen]

What I think you're missing is that the FSF is an oxymoron. The GPL does not create code that is necessarily gratis, and it's certainly not libre. It's full of restrictions, as your article points out. That's nothing like unfettered! It's clearly non-free. The FSF have their agenda, and these are clearly more extensive in scope than the BSD crew's.

Of course, whether you consider that good or bad is up to you. Personally, I believe that a simple, sweeping, blanket `good' or `bad' label is oversimplifying a complex matter. Obviously both licences are doing something that their authors want them to do. But let's disabuse ourselves of this maliciously deceptive `free' thing right here and now. The word was redefined by the FSF to mean something no one but lawyers, pharisees, and related zealots would find intuitive. It's a mean trick.

I've said it before, and I'll say it again. Drop the word `free'. It's a lie. One can continue to repeat clever sophistries until the sun goes nova, and continue to be very clever, very punny, even technically correct in at least one particular circumstance. But one is still completely misleading to virtually all the world.

A few days I was asked by a regular person -- not even a script kiddie -- whether [random software] was `freeware, or just shareware'. See that? Here's a simple test. Go out and ask 20 teenagers whether free software (which they'll call freeware) ever costs anything, and you'll find that 100% of them say, `What, are you crazy?'

Recently, I witnessed a newcomer to the net asked an oldtimer about what possible licence was on a piece of software the latter had written. The sum total of the oldtimer's response was "Do whatever you'd like with it," which surprised the newcomer, who obviously wasn't used to truly free software (unlike the FSF's insidiously deceiptful notion of the same) But what a pleasant change! Where did that complete generosity disappear to?

Let's face it. We've lost this battle. We have to stop hurting our own goals by beating a dead horse. We must instead use a real word in the way that everyone understands it. Of course gratis and libre are lovely distinctions, pero por desgracia, ocurre que todo el mundo no entiende castellano. :-)

Instead of gratis, perhaps we should say cost-free. See how clean and simple, how unambiguous that word is?

Instead of libre, we might say something more like hackable; that's my own original preference, but it has its own attendant difficulties. Less charged alternatives include changeable or mutable or legible or open source or as source code or in some cases, perhaps unrestricted. Historically, we used freely redistributable as distinct from public domain, but that's a problem term because it has the `free' bug, and doesn't specify source code.

I may not be certain about what the right word is, but I'm completely certain what the wrong word is. The wrong word is `free'. Please, please, PLEASE drop these word-games that only cause everyone on the outside to get confused just so that those on the inside get to gloat about how much smarter they are than the rest of the word. It's long past time to face the fact that we've lost the battle for this word, and perhaps time to realize that it was always the wrong word right from the get-go.

Free software is great. Don't destroy it with restrictive licences.

Morality Matters

[Tom Christiansen]

It sounds like this is splitting hairs, but it makes sense when considered in terms of the goals of the FSF and the GPL: to encourage better software through the availability of source code.

The GPL is a form of coercion, a type of strong-arming of which Godwin would be proud. No one likes being forced into doing something. They chafe. They grumble.

More importantly, when coercion is involved, all personal responsibility, all moral choice is removed. You cannot extoll the virtue of someone who adds publicly available code to an existing GPL codebase. There is no virtue invovled, for he had no choice in the matter. Without choice, there is no morality.

Contrast this with the individual who initially creates open source and gives it away to the world. `If you love something, set it free; if it returns to you...' comes to mind. If fixes and enhancements come back to him, then the author of those updates has himself made a moral decision. How much more precious a thing this is than the prisoner who did as he was coerced to do!

It is clear which man has made a moral choice, and which one has not. Coercion is fundamentally opposed to morality.

Mutual assured destruction

[Tom Christiansen]

GPL encourages reinvention of the wheel, not BSDL

You've hit the nail on the head here.

Ever see what happens when someone tries to combine something like the proprietary Oracle libraries and something like GNU DBM or GNU readline or GNU getopts into one program? Do you know what happens?

It goes boom. This is not a pretty picture. In fact, the developer is forbidden from doing this. Gosh, that's just wonderful, eh?