Become a fan of Slashdot on Facebook


Forgot your password?

Feature:GPL vs BSD 359

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.

This discussion has been archived. No new comments can be posted.

Feature:GPL vs BSD

Comments Filter:
  • by Anonymous Coward
    GPL is good in a world where everyone plays by GPL rules. We don't live in such a world yet. At present we have a significant non-GPL world.

    What I really hate about GPL is that many people seem to believe that the success of Linux is due to the GPL and thus GPL must be a good thing. I am convinced that Linux using a BSD license would have had the same success. The success of Linux is a success of free software, not of GPL.

    An argument against BSD License is that someone might fork the code or takes advantage somehow. I ask the readers to give me an example where something like this hurt the various BSDs..

    Regards, Marc

  • by Anonymous Coward
    Not even that. Yes, it can be incorporated into proprietary products. It can also be incorporated into other free software products (including GPL'd stuff). I prefer 2-clause BSDL (as used in FreeBSD and elsewhere) or the X license not because I want to give proprietary software vendors the freedom to use my code (although I don't care if they do; fine by me). Rather, I prefer such licenses because they don't discriminate against other free software licenses. GPL'd code does not coexist with other licenses, period. If you use GPL'd code, your own code must also be GPL'd. If someone wanted to use GPL'd code in some project using some perfectly acceptable DFSG-compliant license (such as Artistic), they couldn't do that. They would have to GPL their own code. The benefit of shutting out potential use of my code in proprietary software is far outweighed by the sheer irritation of shutting out the rest of the free software community. I prefer very lenient, non-GPL licenses because I want my code to be as useful to as many people as possible, and I want a minimum of legalese, and I consider myself to be a programmer rather than some political activist/extremist on an anti-IP crusade.
  • by Anonymous Coward
    There is well written essay by a BSD style license advocate in vil.html [].
  • by Anonymous Coward

    The GPL is rooted in science. As everyone knows, modern science was born in the 18th century when scientists began openly publishing their methods. Before the arrival of modern scientists, the pseudo-scientists of their day were known as "alchemists". These deluded individuals insisted on keeping their work proprietary for much the same reason that latter-day pseudo-scientists keep their work secret. There was no modern science until the strangle-hold of the alchemists was broken by the open publishing of methods by the early modern scientists. Science was created and progress continued as each new generation of scientists could access and build upon the works of others who had labored before them.

    The GPL continues the scientific tradition by realizing that progress in the the scientific arts of computer science depends on keeping its results open and protected from the latter-day alchemists who would turn science back to the dark ages of secret dead-end paths. Those who created the GPL realize that maintaining the open scientific tradition is far more important than providing free labor for rip-off artists. The freedom of the GPL is the same as the freedom of true Science--progress through open sharing of knowledge, allowing us to stand on the shoulders of those who have gone before, so that we may see farther than they.

  • by Anonymous Coward
    do we also need the rights to modify the code, distribute modifications, and incorporate it into other projects

    We don't NEED the rights to play with the code of others. WANT the rights, maybe. Interesting how you don't want others to use your code in any way they want, but you "NEED" the right to do the same with theirs.

    other free projects, if GPL'd; other closed projects if BSD licensed

    "other enslaved projects if GPL'd; other shared or non-shared projects if BSD licensed" is how I see it.
  • by Anonymous Coward on Wednesday June 23, 1999 @05:04AM (#1837226)
    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.
  • by Anonymous Coward on Wednesday June 23, 1999 @05:29AM (#1837227)
    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.
  • Good point, I hadn't considered that...

    But let's take another look at this... Say we have some project... Say this project is building a Snarfblat... Joe Coder starts building the snarfblat, and releases it (in true OS fasion) as version 0.1.

    Now Bob downloads the source, plays with it, finds some broken things, and send Joe a patch. Joe incorperates this patch into release 0.2.

    So now who owns the code? I'm assuming that our helper, Bob, didn't state that he was putting his patch under the GPL, but rather just sent it to the author. Would this be public domain, and hence the copyright for release 0.2 would still remain to Joe Coder?

    Man... I think I blew a gasket on that one ;)
  • I think you missed the question..

    I write a an app and put it v.1 under the GPL... If I, as the author, want, I can release v.2 under BSD or a restrictive license or binary only.... right?

    Oka.. now say someone sends me a patch *with*no*license* attached to the patch. Does this put the PATCH in public domain? Meaning I could add it to my product and I would still own everything in there, and hence would be able to change the license on my work as I see fit?
  • No... I think your getting confused here...

    As the author of an app, I am free to choose whatever license I want. The license affects those who I give the source to, not myself. Once I relase under the GPL, I can't stop people from redistrubuting that version or from changing it, etc, etc...

    I am free however, to release the same code under a different license because I OWN the code. It's mine.
  • From the GPL:
    > Each licensee is addressed as "you".

    So while reading the GPL, keep in mind that it's being addressed to the Licensee, not the author.. the author still retains full copy(right|left) of (his|her) code... and as such, can change licenses at will
  • >Unless the author is the liscensee, as you put
    >forth in your original example. Joe liscensed
    >his work under the GPL, becoming the liscensee,
    >and therefore subject to its restrictions.

    Hmmmm.. Joe placed his work under the GPL... he is not a liscensee but the author... there is a difference... A liscensee would be anyone else who took the code from Joe..

    >to modify, you automagically have your code
    >placed under the GPL.

    To modify *someone*elses* code... yes... Your own code, no. Your code is copy(righ|left)ed by you.. you can change that copyright on future versions, but the version that was release under GPL can still be modified and redistributed under the GPL.

    The GPL is about *re*distribution. The author will distribute, other will redistribute.

    >Note: I'm really interested in this, since I
    >really don't know. I've got some code I might
    >release, and I'm currently looking at these
    >Liscenses. I'd like to be sure that I understand
    >this all first.

    Understood... It's all good.. I enjoy a good level headed discussion..

    Side Note: No one reading this thread will see this, but oh well. This has been one of the best set of comments on Slashdot that I've seen in a long time. Everyone is (mostly) being cool and discussing... Maybe the script kiddies are still asleep.

  • by Zack ( 44 ) <<zedoriah> <at> <>> on Wednesday June 23, 1999 @05:12AM (#1837233) Journal
    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.
  • 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.

    I think this is a large misunderstanding about the BSD license. If someone takes your code and makes a proprietary product out of it, your code is still there. You can't see the modifications they made to it but your source code is still out there on the internet and anyone can still use your code. They have taken nothing from the community by using your code in their product. The copyright to your code is still yours.

    Now, that's not to say I agree with a company taking code and not giving back. I'm just saying that they are not removing our access to our code, they are adding to the code and selling their additions. They are removing our ability to modify their code. If you want to modify it, modify our version. Oh, and while you're at, add those extra functions if they are so great people are willing to pay for them.

    If you are concerned about people taking your code and not giving you credit there is a BSD license to take care of that. Just add a clause to say they need to credit you. I think it's a selflessness thing. BSD is a giving license. Here, take this code and do whatever you want with it. GPL is a give/take license. Here, take this code but if you modify it you need to give it back for the rest of us.

    Personally, I haven't yet decided which license I want to use for my projects. I don't know if I'm selfless enough to allow someone to take my code and not give back. I wonder, if I found someone using my code in a way I didn't like, could I terminate their license?


    Rick (rick at chillin dot org)
  • >For those of you who will say "Well, they didn't
    >snatch up BSD code" I say "How do you know")

    So basically your saying that MS used BSD code without giving credit (which contravenes the BSD licence) yet hasn't done the same with Linux code just because of the GPL?

    You really haven't got single a clue have you?
  • by drwiii ( 434 )
    The bottom line is, the GPL is not anti-commercial or anti- capitalistic; it is only anti-proprietary.

    One could also argue that the GPL makes code proprietary to freedom.

  • Hint: It already does not matter to many people that linux won't run office, quicktime, etc.

    Hint: It also does matter to many people that they can't view [insert movie trailer here] because Linux doesn't support the codec.
  • 1) It is not GNU/Everything. GNU/Linux is the only item with which the issue has come up. RMS's position (that I happen to agree with) is that the Linux kernel is merely the final piece of the GNU OS (since HURD is not done), as as such, the OS is a GNU/Linux hybrid system.

    2) RMS did not try to enforce this. He merely suggested it. He will not sue anybody for calling their OS just "Linux." BSD authors, on the other hand, could indeed sue if you left their name out of the credits.
  • 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.
  • by HoserHead ( 599 ) on Wednesday June 23, 1999 @09:37AM (#1837240)
    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.

  • >Damn - I'd hate it everyone had an OS or
    >software that worked.

    Wouldn't you though? That is what some of the folks who are proprietizing BSD code could stop. They take the code, proprietise it, and make sure it runs only on their own hardware or that it runs only their software.

    >The point is that the BSD license allows more
    >freedom of use because companies will not use
    >the GPL or they won't survive since they can't
    >sell their value-added product because the
    >GPL would force them to give the source to it
    >to everyone, including their competitors.

    That is PRECISELY THE POINT! Companies take BSD code and HOPEFULLY provide enhancements to the codebase back to the developers. You WANT them to use the code and I can respect that. You evidently want a world where there is free and open cooperation - so do I. I just don't trust corporations to go against their profit motive and that includes proprietizing the formerly open code and NOT providing enhancements to the codebase back to the developers.

    >Do you honestly expect WordPerfect, Oracle, or
    >any of the other big commercial vendors who've
    >jumped on the Linux bandwagon (primarily for
    >the PR) to actually release their source?
    >Not a chance.

    This is precisely my point! I EXPECT them to NOT provide enhancements back unless it enhances their profit potential. I understand that they will proprietize source code - that is the whole basis for my logic. Please convince me otherwise if I am wrong as per my tagline.

    >The BSD license gives everyone the chance to
    >have a good fill_in_the_blank. Witness the
    >TCP/IP stack that the Internet lives on -
    >from BSD.

    I most assuredly agree! I just don't trust corps to be good citizens - it is against their very nature.
  • >You say having a good, working codebase is such a
    >bad thing.

    No, I didn't say that at all! Having a good, working codebase is a Good Thing(tm).

    >You rabid GPL advocates are always going around
    >with the scare tactic of "oh no, somebody MUST
    >be stealing all your code!

    I'm not a rabid GPL advocate. I just see the GPL as the best way to ensure that the code stays free as in freedom.

    >First off, you can't steal what is given away

    Can't dispute that!

    >Second, as I've said time and time again in this
    >discussion, the GPL is not a magic wrapper around
    >your code, protecting it from the "evil"
    >corporate coders who might steal your code.

    True again. Any code that is available can be taken. It's just that if they are caught then there will be serious legal repercussions that many corporations would not like to fund. As such, the GPL works for the purpose it was intended for as does the BSD license.

    >Get over yourself; maybe your code isn't worth
    >stealing anyhow :)

    I've got a job in programming that says my skills are valuable. I choose not to give them away with no chance of recompense. When I write code for GPL release, I feel that I am contributing to a codebase that provides me with an Operating System and Applications that are outstanding. It's my way of contributing to the community. I know that the BSD folks are contributing SELFLESSLY. I congratulate them for thier baseless and pure hearts. I trust them; I don't trust the corporations.

    Anyway, what has this, "Get over yourself" stuff got to do with anything?
  • >By this logic, then, the Linux source code has
    >absolutely no value?

    Value is a measure of a thing's worth to a person. Linux has much value to me in that it provides benefits.

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

    Interesting scenario! Why not have the corporation make a deal with the copyright holder for the rights to use the aforementioned GPL code under a commercially viable license?

    Or, the corporation could participate actively in the community both gaining the use of and contributing to the GPL codebase?

    The GPL forces anybody that wishes to use the code for profit making purposes to play or pay. If something has value then the buyer must be willing to pay a price for it.

    Corey, I like your point of view. Actually, I believe we agree with each other more than disagree. From your standpoint, the BSD license is evidently the best choice and from mine, the GPL's protection from being coopted with no rights whatsoever is the best choice.

    I believe I understand your position alot better than I did when this thread first started. You really don't care if they take the code - as a matter of fact, you are expecting them to.

    GPL and BSDL - two fundamentaly different licensing options with strangely similar goals - software freedom.
  • >What kind of reprecussions are we talking about


    >At best, you could force the company to release
    >the source code or recall the product, and at
    >worst the gpl would be declared invalid.

    Declaring the infringing codebase as GPL would satisfy me. If the GPL were to be declared invalid then... well... (it is a subject that deserves to be explored further).

    Personally, I feel that the GPL is sound.
  • 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.
  • >Then you should respect their wishes to allow
    >their code to thrive whenever and wherever it

    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.
  • Posted by The Famous Brett Watson:

    I've posted this link before, but it's as relevant as ever, and judging by my web logs most people haven't seen it yet. If you were hoping for something a little more substantial than this "feature", then I can't help you, but if you were looking for something a lot more substantial, then refer to my essay Philosophies of Free Software and Intellectual Property [] ; seventy kilobytes of HTML in which I lovingly beat the subject to death with a heavy, blunt object. Enjoy.
  • 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.
  • There are several examples of where code forks in BSD projects have hurt. Emacs vs XEmacs is one example, and the split that created OpenBSD from NetBSD is another.

    Er... Emacs and XEmacs are both GPL'd. I don't see that the BSD/GPL issue has any relevance to forks (except that you could look at the BSD license as an invitation to 'fork' off a proprietary product with no adverse consequences).


  • The purpose of this product was to make it possible to distribute source code that could be built and
    linked with other code (extendable) without it being possible for people you didn't want to poke around
    in the code and figure it out. Unless there are readability standards imposed in any licencing sceme (i.e.
    the GPL) I think this would be an excellent vehicle for organizations hostile to the GPL to incorporate
    GPL'd code in their products, extend, the code, but totally snarl up and render unusable the source they
    are required to release with their product. It seems like the inevitable endpoint of arrogant licenses like
    the GPL.

    From the GPL:

    The source code for a work means the preferred form of the work for making modifications to it. For an executable work,
    complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus
    the scripts used to control compilation and installation of the executable.

    I read this to mean that a 'shrouded' version of the source is not acceptable, since your company would make its modifications to the 'unshrouded' version.


  • ...releasing your software under GPL effectively stops you having control over it.

    Not true. You are free to release code that you write under any license at any time, and under different licenses to different entities. Perl and Ghostscript are both examples of this freedom.


  • If this clause of the license holds, then it makes sense that it should be prohibited to GZIP or in any way compress GPL'd source code before distribution. There's no distinction made here between reversable or non-reversable obfuscation, and I don't know ANY coder who works directly with source code that's tarred or gzipped in any way or form.

    I don't see that it's possible to 'draw a line' here creating a distinction. Therefore it's impossible to police.

    Interesting point. I do think you can draw a line--it's precisely your distinction between reversible and irreversible transformations. I agree that the GPL doesn't explicitly address that distinction, and I think a court would have to take into account the intent of the GPL to decide whether tar/gzip was legally different from 'shroud'.

    Be interesting to see what rms says about this issue...


  • I find it interesting that you berate Microsoft for not releasing their code on one hand, and then you accuse them of wanting to steal your code on the other hand.

    No, I don't think that's what he was saying. He doesn't want Microsoft to MAKE MONEY off of his code without contributing to his effort somehow.

  • And how! That guy has been trolling for weeks now, posting anti-Linux, anti-GPL screeds, and attacking this site and its readers/particpants. Indeed it makes you wonder why he sticks around here. Some people just like to be miserable, I guess, and want to spread their misery around.

  • There's only 4 forks of BSD, and AFAIK no one else want to create another -- that's undue paranoia. Also, it's not like the GPL can *always* prevent forking; two of FSF's own projects (gcc and GNU emacs) have forked (egcs and XEmacs, though egcs was recently declared the "official" gcc).

    -lee...never mind that Unix's own history tree looks like a Manhattan subway map...
  • >Sometimes I wander if its all the PHBs who say that BSD is better cause they get free stuff without rewarding anyone...

    With either the GPL or BSD, plenty of people get free stuff without rewarding anyone. The big difference, seems to me, is that the GPL prevents programmers from getting free stuff. And many of those programmers, even if they make a proprietary version, would contribute to the free version to make it easier for them to take advantage of other improvements to the free version.

    How many of those web sites that run Apache/Linux contribute? How many of the companies that run Linux fileservers or mailservers contribute? I'd bet it's a darned small fraction.
  • > there is no way you can include that code into
    > another closed product

    You are missing the distinction between copyright and license. If I write code, I own it and can license it as I see fit. Users of my code have to abide by the license, but I, as the copyright holder, do not. I am free to release under a different license if I want to.

  • > I use BSD, don't like it fine -- USE my code.

    That's not entirely true. I still have to comply with your license to use your code. It's just that your license is less restrictive than mine.

    There's no doubt that the BSD license is the more generous of the two. I'm just not as generous as you are, I guess. I'm willing to donate my code to the community -- but only to that portion of the community that are willing to do the same.

  • > What is obnoxious is trying to track down all
    > the contributors to GPL'd code to
    > get permission to do something to it.

    You don't need to track down the contributers to do "something" to the code. You only need to track them down if you want to change the terms under which they (generously) donated their code the open source community.

    This isn't obnoxious at all -- it's just common courtesy.

  • Nope. The app is under GPL. If you modify the source, then that is GPL'ed too. If you don't want it to be, then you should have read the license before you started tinkering with the source code.

    The BSD licenses don't have to worry about this. Anyone can fork the tree and change the license. With a GPL'ed product, anyone can fork the tree, but it'll stay GPL'ed, which means that reincorporating changes like this doesn't run up against any licensing restrictions.

    Basically, if MacOS X was built on top of Linux and used lots of GPL'ed code, then most if not all of it would be released under the GPL, and people would be furiously developing it, and incorporating the (good) changes into Linux as well. It isn't, though, it's proprietary, and whatever Apple does release is done out of the goodness of their little corprorate heart. BSD got forked again, and they're happy about it.

    So pick the license you like best. I like the GPL best because I want to see what people are doing with my code. I don't want any license that takes *that* right away from me.
  • If linux had been licensed under the BSD license instead of the GPL, Microsoft would have snatched a ton of the code up into windows by now. (Guaranteed there would be no credit given.)

    Why? Architecture-wise NT and Linux are very different (monolithic vs. micro-kernel (well, sort of! )). Sure they could take ideas, but quite frankly NT's kernel does a lot of things better than the Linux kernel. Both have their strengths, both have their sore-points.

    (For those of you who will say "Well, they didn't snatch up BSD code" I say "How do you know")

    This is a company that doctored evidence for their trial. How do you know there isn't a ton of GPLed code in Windows? Do you think they'd have the slightest misgiving about doing so? ;)

  • >Yeah, but we can always find a good lawyer who'll go after them pro >bono for the publicity.

    Exactly. Can you imagine the kind of publicity someone like Nader could generate with a court case like this?

    As the Microsoft lawyers are being taught in the anti-trust case by the laywers working for the DOJ, it's not about how much money you have or the number of witnesses you try to buy off, it's all about how you play your hand....
  • So, someone like Troll could release qt under the GPL. Then it remains completely free in the source access sense and for purposes of forking. However, it would be unusable as source for purposes of 'embrace and extend' and anyone that wanted to use it for a proprietary product would have to pay Troll for a different licence.
  • That is typically how liberty, rather than anarchy is defined.
  • Software that can sell millions and keep on selling millions after the development has been paid for simply doesn't NEED fill in the blank style help from the like of you (or BSD developers).

    That sort of thing is simply needless corporate welfare.

    It's hardly killer advantage of the BSDl.
  • The main goal of the BSD license is to improve the quality of software, both proprietary or free.

    The main goal of the GPL is to promote the free software cause.

    Both licenses do a good job at achieving their goal. Both goals are honarable. People who speak ill of either license are twits.

    PS: the GPL vs BSD license debate predates Linux.
  • As for forking, the Linux camp holds up the GPL as the anti-fork for Linux. The 32 different flavors (FORKS) of Linux help the anti-fork argument how?

    Thats a pretty little argument you got there but let me tell you why you're wrong. I totally agree that there might be too many Linux distributions, but they are not forks. "Linux" is the kernel. There have been no major kernel forks to my knowledge. There are unofficial patches here and there, but were talking about small diff files here, not a true fork. Distributions are just collections of software that work on what we call a Linux system. Although there are many, they are for the most part compatable. Take the Metrowerks Code Warriror example, it says for "Red Hat Linux", well shit on them, as long as I provide the same libraries that thing is linked against I can run it on Slackware, Debian, or whatever. Anyway, you all get my point.

    /* I also am a fan of xBSD, I run both Linux and BSD, will wonders never cease... */
  • Exactly, however I might tend to release under the LGPL for that reason, its the best of both worlds. It allows propritary linking, but keeps the source free. Under a BSD Style license company large company X takes great new piece of code under a BSD license, changes it to suit them and releases it closed form. If that company has enough market share, clout, whatever, that new closed standard takes precedence. However if it was LGPLd, the changes must be made available, and therefore cuts down on that kind of shady standards tweaking.
  • Just to mix things up a bit: What about the LGPL vs. a BSD style license?

    I believe that if you want to keep control of your code and still allow its use proprietary products the LGPL is the only way to go. For me the BSD license seems too close to just releasing as to the public domain(which is the *most* free technically).
  • What we see here is a fine example of the tone and clarity that should be used when stating or defending one's position. This is especially the case when defending Linux or Open Source to media members and/or software companies that publish uninformed articles decrying them.

    You catch more flies with honey than with BS.

    Posted by the Proteus

  • How about MS-Linux? Microsoft could TAKE Linux and turn it into a proprietary product. Most people would assume that Microsoft originated the PRODUCT and buy their version.

    Most of the articles about free software and Linux talk about the danger of fragmentation. Fragmentation is not a big problem with GPL. But with a proprietary product it would be.
  • thus forcing him to possibly reinvent the wheel when he could have simply used the GPL'd code

    Whos code? ---------> GPL'd code

    You have no right to exercise rights over *HIS* code.

    But you want to use my code! Huh?
  • So he no longer controls "his" work. Same thing for any other GPL'd work of any magnitude.

    That is a good thing! That is what we want! You effectively give your code to the free world! Then there is no turning back. I wouldn't have it any other way.

  • the GPL would force them to give the source to it to everyone, including their competitors.

    WP didn't release their source, did they? So what 's your point?

    Think of it this way. IBM could release code as BSD but are scared because their competitors could use it in their products. But if they use GPL they know it can't be used in another product. So IBM, HP, Compaq can all contribute to a common OS. They will all benefit.

    Here is my value-added : Linux with WP on top!
    No need to release code.
  • In practical terms, BSD-style licenses exist for the purpose of declaring the author can't be sued. And that's pretty much it. Unless you're worried about being sued, there's really no reason to release something under a BSD-style license -- just release to the public domain.

    I used to gnash my teeth over the oxymoron of a "free software license", and rally against people using the GPL instead of just releasing something to the public domain. Eventually, though, I realized if I wanted my code to remain free, something like the GPL is a necessary evil. But if you're not concerned about it, go ahead, release public domain, or BSD if you're paranoid about lawsuits. This is a really stupid thing to fight a war over, even if it's just a flame war. Let each author do as he/she prefers...


  • Microsoft actualy *bought* their BSD tcp/ip stack from BSDi for something like $10Million. They did not steal it.

    And the BSD license does not permit companies like Microsoft from stealing code and not giving credit. Read the BSD license some time and look really closely at clause 2, which states:

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

    So they have to say where they got the code from. They can't just steal it and not give any one credit.
    And if the BSD license "drain developers from the BSD space" why are the *BSD projects still around? I don't see a mass exodus of develpers taking off to go work for Microsoft.
  • Take a look at the BSD license again. It clearly says:

    "1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer, verbatim and that no modifications are made prior to this point in the file.
    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."

    So you have to give credit to the author when ever you redistribute source our binaries.
  • Just a couple of things... whilst I believe that Zack is correct, I would recommend talking to a license lawyer (if there is such a thing) (definately NOT an intellectual property lawyer!) if this something worries you. Also (assuming that my understanding is correct), the author can release v0.1 under any license he likes; releasing it under the GPL does not also prevent him from releasing it under an entirely proprietary license at the same time.

    Theoretically you could release under the BSD and GPL licenses at the same time (although these would have to be seperate instances of the source code, each with their own license).

    In fact each time the author gives his code to someone he can give it out under a different license.

    Why anyone would want to do this is entirely beyond me, though...

    P.S. I favour the GPL from the purely practical viewpoint that I believe it encourages greater code reuse and collaboration, and protects the rights of the author(s) better.
  • The phrase, intellectual property, are for a lot of us profane in itself.

    The notion of intellectual property allows people to own ideas, which in itself is mistaken. Intellect, is not an idea, but a stream of ideas. An idea in itself is worthless, if it is not followed by a steady stream of new ideas. And the fact that we allow ownership of single ideas is simply mistaken, because one idea has infinitesimal value compared to the world of innovation we live in.

    I think RMS did the right thing, by creating a licence that will satisfy everyone that acknowledges that innovation or intellect is not a matter of one idea. It is a matter of securing that enough people will be allowed to continually contribute new ideas to the original idea.

    Owning one idea will only make further innovation suffocate. That is, ofcourse, a perfect situation for a lot of corporations and individuals who do not mind enslaving their users into this primitive proprietary world where problems are accepted because they will be fixed in the next release, which again probably will be available with a discount.

    It's a sick world out there, but fortunately a lot of people have the clearsight to release their innovations in a way that acknowledges that they can never be the be all and end all of innvation by themselves.

    Cooperation is the key word. And that just don't mix with the misguided desire not to share. If one wants to be alone with the idea and the profits, one will end up very alone with incomes long gone and an old idea.
  • I don't think that kind of code would legally constitute source code. The company would still be holding its own original copy with full documentation... a version which could not be released without running it through this "shrouding" utility.

    Shrouding sounds like an intermediate step, kind of like compiling without linking. Just because it has to be compiled to be useful, it does not mean that it is source.

    It's an interesting point though... I wonder if the wording of the GPL accounts for this...

    Just imagine the company trying to defend themselves in court. "If this is the source code, why is H23F476 calling B343256 on line 320 of X353423.c?"

  • And I don't consider FreeBSD/OpenBSD/NetBSD forks. I consider them to be different projects with different goals.

    And I don't see how, had they (or 4.4-Lite) been GPLed, that would somehow magically have kept us from having three different free software BSDs (which, as they're free software, can pick up work from the others).

    Perhaps their real argument is that, had the BSD code been GPLed, the non-free BSD-derived systems wouldn't hae existed, and are confusing those systems with {Free,Net,Open}BSD, all of which are free software - I've seen no solid reason why GPLing BSD would magically have kept those from coming about, so if people want to offer credible pro-GPL arguments, they should either demonstrate why the GPL would magically have ensure that we have only one BSD that's free software, or stop citing the existence of three of them as an example of the Bad Consequences of the BSDL (of course, others might debate whether that Consequence is, in fact, Bad...).

  • To be honest, so far (at comment 13 at any rate) the comments have been insightful and thought-provoking.

    Maybe Slashdot is growing up a bit...?

    Of course, the tide may turn as soon as people start logging in...but all in all I'd say it was a good sign (I was expecting a bit of a war too).
  • How many times do we have to go through this?


    Its a message board you moron. People come here to sound off.

    Excuse me for hoping for intelligent discussion on this topic (as one could find in plenty of other articles on Slashdot). Just because you can't provide any...

    You can lump yourself into the same your own post. At least I assign a name to mine.

    What category? Name?

    Clearly "sounding off" is to the complete exclusion of comprehensibility.

  • I apologize, I totally missed the "BBS Wannabe" reply.

    I concur 100%.
  • 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.


  • Well, it depends on how you define freedom. With a BSD license no one can take away the code you released under the BSD license. However, they can add on it and make the add-on code non-free. I consider the BSD license more free, personally, because it does not impose restrictions upon the way others release their own code.
  • So what?

    Let's say linux was released under the BSD license. Let's say MS decided to make a closed version of linux. Let's say most people did not know any better than to think MS invented it. So what?

    Would any of these people contribute in any meaningful way to the linux codebase anyways? The only difference it would make is that the OS on most people's desk wouldn't suck, and MS would make money. That doesn't bother me.

    Furthermore, may I point out that free versions of BSD UNIX still are alive and kicking despite proprietary versions by Sun (Solaris still has a large chunck on BSD code, even though it's now pretty SysV, however, old SunOS was BSD to the core), and BSDI. Fragmentation amongst the free versions has been much more of an issue than the existence of proprietary versions
  • Actually the NT microkernel is supposed to be pretty decent (at least according to a number of people I knew who worked on different parts of NT). It's the Win32 API and various other OS pieces above the microkernel that is shit. Therefore, if they tacked their various bits of ugly code on top of BSD UNIX, little would change.

    Of course, in the world of commercial unices, there's CDE. Kernel code for various commercial unices is pretty decent, but CDE is awful code (IMHO). At least in the unix world, KDE is becoming more and more accepted, and it's code is pretty damn nice (the X server's code isn't too bad either)
  • It's hard to have a non biased look at both sides of any argument, because someone with enough interest to research both sides will develop a favorite.
  • Um, actually this is obviously wrong.

    takes BSD license code, adds a bell and a whistle, and releases it as their corporate blessed version. The free version suddenly loses credibility. Managers want to buy the proprietary version. Few people develop for the free one. Soon the market is centered around the proprietary version, and there is no real free alternative.

    Seeing as this has already happened several times, I don't see how you can overlook this. I deal with this constantly, as the company I work for uses a variety of tools which will run on BSD systems, but only the proprietary ones!

    GPL avoids being marginalized like this.
  • that was supposed to begin "your favorite company...", but it got eaten.

    guess that will teach me to use the preview button.
  • They've also marginalized the free BSD's, as anyone knows who's tried to use a BSD in a corporate environment: you can't get code for a free BSD, but BSDI is usually supported. So you're back to running a proprietary o/s.

    GPL has saved Linux from the "fork and marginalize" syndrome of BSD. If a company develops Linux code, you can bloody well run it on your Linux box without buying LinuxI, or something. ;)
  • (um, no, i don't mean flaming :)

    Most of the comments are very abstract. How about some real life examples?

    For me, I rail against the BSD license every day, for two reasons:

    1) My place of work uses a variety of tools which run on various Unices, including BSD, but NOT the free varieties. If I want to run BSD I *have* to use a proprietary version. This is only possible because of the BSD license. GPL would not allow the proprietary fork. Proprietary BSD's have marginalized the free BSD's, which is possible because of a poor choice of license.

    Linux distributions are not "forks", because *any* Linux product will run on my linux box. At most I might have to install a different libc, or something, to get it to work. I don't have to buy a proprietary Linux.

    2) A company I've worked for is basically making widget frosting -- code to run with its hardware. Where did the code base come from? BSD. This company has *no* investment in this code. They want to sell widgets. If it were free code they'd still sell widgets. It won't be free code because the BSD license was sitting there, allowing them to walk off with it. BSD had a valuable code base, which could have been extended. Instead it has been swallowed, because the license allows this waffling. This happens all the time: BSD is undercutting the development of free code.
  • with any license the original developer is free to release her code under another license.

    with the gpl, every contributor can continue to see the changes made to the code.

    with the bsd license, the original author and the other contributors have a good chance of using software written by them, but not modifiable by them.

    with the gpl, the phrase "gpl license" contains an extra word.
  • "The adoption of license should be based on different situation - GPL tends to be more suitable to fun or volunteer projects"

    So if redhat spent $2.2 million on development last year, and the coders just did it for fun as volunteers, what exactly did they spend that money on? and va research? and the developers at cygnus that help maintain the compiler that all the *bsd projects use, i suppose they just go into the cygnus offices and then leave each night to beg for food?

    and which sells more: redhat linux or the freebsd cd? actually any of the linux distribs vs all of the *bsd's sold.

    it's not enough to keep your eyes open. you have to actually reach out and take the clues as they float past...
  • 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.
  • You can change the license on code you have written at any time. The change is not retroactive though - anyone who had a copy of your original GPL'ed code may continue to use it according to the terms of the GPL, no matter what new license you have applied to since.

    W.r.t. to the patch question, I believe the only safe assumption is that the patch author wants his patch to be under the same license as the code he modified. Unless he specifies otherwise, that is.

    If you want to have the option of changing the license later, you could ask patch-authors to transfer copyright for their code to you. If you ask nicely, they might even go for it - after all, they still have a copy of your original GPL'ed code which they can fork if you go proprietary all of a sudden.

    This makes for a good strategy for library writers who want to share their efforts with the free software community, but want to get paid if non-free programs use their code:GPL the library, thus banning proprietary use - unless you get paid! :-)

    I like the GPL.

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

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

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

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


  • 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" :)?
  • 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.

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

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

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

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

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

  • by ethereal ( 13958 ) on Wednesday June 23, 1999 @06:42AM (#1837366) Journal

    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.

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


  • by GeneralTao ( 21677 ) on Wednesday June 23, 1999 @05:20AM (#1837402) Homepage
    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.
  • 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. l []

  • "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.
  • by cmc ( 44956 ) on Wednesday June 23, 1999 @05:31AM (#1837458) Homepage
    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.
  • 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.

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

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

A committee takes root and grows, it flowers, wilts and dies, scattering the seed from which other committees will bloom. -- Parkinson