Zed Shaw just blogged about why he uses the GPL instead of a BSD-style license. His arguments for the GPL are interesting but I feel that counterpoint is needed, since at Enthought (where I work), we try to BSD as much of our code as possible.
“It’s the Author’s Right”
First off, I’d like to encourage everyone in the Python community to be respectful. It is never appropriate to get angry at another person for their choice of license, and I am disappointed that Zed feels slighted by the community reaction to his work. (If you don’t like the license on a package, it is sometimes appropriate to ask the author if they’d consider changing it, but obviously beggars can’t be choosers.) Hopefully it’s just a few bad apples (“ungrateful turds”, as he calls them). That being said, “it’s the author’s right” is not really a reason for the GPL, just an admonishment.
“I Don’t Want To Be Ignored Again”/”You Have To Tell Your Boss You’re Using My Gear”
The fact that Zed wrote Mongrel and got no recognition is possibly an indictment of several things: the RoR buzzstorm, the Rails community, the “OMG Ruby is the new Java for Web 2.0” technorati, maybe even venture capitalists. But it is not an indictment of the BSD license.
Numpy and Scipy are two very successful projects, and they are BSD licensed. They have healthy communities, and many people make a living off of consulting work or commercial projects built on those tools. There are also countless companies whose staff make use of them internally, and occasionally give back to the projects. I would consider both Numpy and Scipy to be healthy, open-source projects with plenty of mature collaboration between commercial, academic, and hobbyist users. If either project were suddenly to become GPL, they would lose their commercial viability and the communities would undoubtedly suffer.
SAGE, an open-source Pythonic replacement for Maple/Mathematica/Magma/Matlab, is another very successful project, but they staunchly use the GPL. Their reasoning is much like Zed’s, because the symbolic math software community has been burned in the past by people profiting from proprietary extensions of BSD code without attribution or contribution. However, the GPL means that people cannot realistically use SAGE in a commercial tool, either as a platform/runtime, or as an embedded component. The SAGE authors have, presumably, weighed the trade-offs and decided it’s ultimately more valuable to be protected than to have the contributions of that segment of developers.
The style of license both depends on and defines the type of community that develops around a project. If you feel that the potential audience of your project consists of the sort of people that are liable to use your code without attribution and without becoming part of the user community, then by all means protect yourself with the GPL. If your code is the outgrowth of a community that already has a healthy number of commercial users, then there’s usually no downside risk of using BSD, while you get the upside of reaching a larger audience. Based on what I’ve seen, the Python community has a pretty healthy mix of commercial developers, and so as a whole I don’t think people there get burned by choosing the BSD license.
“If It’s Good, Pay For It”
Here is where we are in agreement, but there are numerous ways to approach this. Phil Thompson uses a dual licensing scheme with PyQT, wherein commercial developers have to pay for it. Travis Oliphant implemented an interesting “world price”/community fixed-fee scheme to fund the development of Numpy: he wrote a big pile of documentation (the Numpy Book) and sold it until a certain total dollar amount had been reached, at which point the book became freely available. At Enthought, we earn consulting contracts based on our BSD-licensed Enthought Tool Suite and our involvement with the Numpy and Scipy projects.
BSD/LGPL does not imply that you will not make money, and GPL does not ensure that you do. The only way to ensure that you *do* make money is to explicitly dual license.
(Edited: as some have pointed out, dual licensing basically requires the use of the GPL with a commercial license, as BSD does not prohibit commercial use.)
“Finally, Value”
I think there is a very good discussion to be had about how to commercialize the success of open source. Talented coders need to be compensated so they can afford to continue to innovate. Users should be free to use code however they wish, with no limitations on their freedoms, because code is ultimately a form of expression. But we need an interaction model that allows the expression of values and economic preferences without grounding certain values to zero, which is that traditional OSS licenses tend to do. As the practice of software development matures, we simply have to find a better economic model than the traditional Stallman-Gates bifurcation.
However, I think that choosing GPL or BSD is orthogonal to whether or not you feel your work is valuable; it is merely a way to define the kind of community you want around your project. If the community is filled with selfish, short-term opportunists, then protect your code and yourself with the GPL. If the community has a large, healthy contingent of commercial developers, then you’re only hurting yourself if you shut them out.
I recognize that in the scientific Python community, we’ve been extremely lucky to have developed the user base that we have, but I think that has largely been possible *because* we use the BSD license.
Objects in Motion 
What I hate about the GPL is that it tells ME what I must do with my project if I want to include a GPL component. It is OK to say what can be done with one’s own work, but I’m offended when told what I must do with my work.
@Phil
GPL doesn’t tell you to do *anything* with your project… if you never choose it.
-m
I have never understood this reasoning. The component that exists has a GPL license from the get-go. If you don’t want to GPL your code, do not include the GPL component. It is no different in that regard than buying a commercial license, if you don’t want to pay the price, don’t use the product.
Further you are not being told what to do with YOUR work, only your additions to someone else’s work. (this point is highly contestable i know, but if you need the GPL component, it is non-trivial for you to replicate, therefore meaning you are adding to someone else’s work.)
GPL is just telling that if you want to use GPL’ed code in your project, you should honor how its authors wanted it to be used, namely, forbidding you to embed it in products that can be closed in the future.
I say it’s healthy.
I guess it comes from labeling GPLed code as ‘free’. It is free for users but it imposes some severe restrictions on developers, thus the mixed feelings toward the license.
Nothing I do would cause a GPL component to become closed. It is out there and won’t go away. However GPL restricts my freedom. I can’t use it unless I play by their rules. So I don’t use it (and I should not have needed to say that).
GPL is free as in beer, but I want liberty. I would not mind enhancing a GPL component and giving that back, but I won’t even look at it because it restricts what new creations I may wish to create.
True, but only if you incorporate that GPL component. Personally I have absolutely no problem with other people telling me what I can and cannot do with code they have written. I can choose note to include it.
At the same time, though, I do find it rather irritating that some projects by nature of the open source license in use, are incompatible with being used with or in other open source projects for rather minimal reasons (NOTE: I consider the GPL side of the whole OpenSSL vs GPL thing to be ridiculous). Principles are important, but things like this can lead to a serious waste of time re-implementing something from scratch, that otherwise could have been utilized, due to some minor licensing disagreement.
Standing up for a principle like “don’t harm other people” has significant value. Impeding collaboration based on minor license-related bickering seems, to me, to be a waste of time. This doesn’t just apply to the GPL, but you cannot say that BSD or MIT licenses are preventing people from making progress.
Nothing is really free (libre) unless you can do whatever the heck you want with it.
Offended when offered a free (as in beer) library to save you from doing all the work yourself? Wow… a new definition of offended here. Do you get offended when offered Coca cola because you really feel like some apple juice?
The proper reply is “No thank you”, not “WTF?! I wanted juice!”.
I’m offended when offered Coca Cola if I must drink it from behind bars. I want liberty not free beer.
So if I follow this analogy correctly, if you truely liberate yourself, BSD style, I am allowed to turn you into my slave. Since you have become truely free, I can do with you as I see fit. Fortunately for me, I am a company and do not truly free myself for such bondage, sure sometimes the jail where i can do most everything i want, but which protects me from being a slave sucks, but usually it just protects me from being a slave. Now come scrub my toilet.
It should not be necessary for me to spell out that my response to GPL is “no thank you”
I want to live in freedom not in jail
Phil, you’re leading out all the usual, tired arguments about the only kind of freedom being an absolute freedom to do whatever you want, unimpeded by others, regardless of how that curtails the freedoms and, indeed, rights of others.
In effect, you’re insisting that things which are privileges should be “rights” or “freedoms” that cannot be taken away. In a broader setting, this would be like insisting that it is your right to take someone else’s property from them and that the law, which typically forbids such acts, is restricting your “freedom”.
In any properly functioning society, freedom involves a compromise between what you can do to others and what others can prevent you from doing to them. Copyleft licences attempt to legislate such a compromise (which some people take exception to), but that doesn’t make them lesser guarantees of freedom. Insisting that such licences are somehow unfree, or (as has laughably been asserted) all about “free beer”, shows either a remarkable lack of awareness or considerable disingenuousness on the matter.
I always feel weird about the benefits of BSD’s encouragement of commercial products.
* if commercial product is also open-source (or Free), then BSD and GPL are the same
* if commercial product is proprietary, do we want to encourage it? For example, let’s look at Apple. If the Mach kernel was GPL, Mac OS X would be GPL, and their GUI stuffs would have been opened to the world, and Unix would be a much better place to live. Now, but Mach is not, and then, Apple go on to pretend that the whole Open Source (and/or Free) community does not exist, that there are only 2 OSes, Windows, and Mac OS, everything else is either weirdo or terrorists.
Thus, in the end, the only thing the BSD ever encourages is the very thing that we want to stay away from!
Magice, how much did you pay for GCC? Or for the Linux kernel? Or for XWindows? So if Apple open-sourced OS X and you could download it for free, how much money are you going to send Apple, out of the kindness of your own heart? Given those numbers, how would Apple continue to support the development of the software?
It is completely false that “the only thing the BSD ever encourages is the very thing that we want to stay away from”. My whole point is that there are healthy free software communities with hobbyists contributors and commercial contributors. Enthought, as an organization, makes its money writing software that is based on free libraries. And we contribute back to those communities in many ways, whether it’s sponsoring the PSF and conferences, or providing servers and bandwidth and consulting time, or open sourcing our own libraries and spending time on their documentation and support.
None of these activities are cheap, but we do it because we are all coders and want to support the community and the code. But none of this interaction would be possible for us, if it were not for the BSD license.
Oftentimes it feels like some GPL advocates treat anyone who wants to make a living doing software as a Big Bad Bill Gates, when in reality it’s usually a bunch of hackers who are no longer living off our parents and want to put food on the table.
“how much money are you going to send Apple”
The full price of many computers I own, from my ][+ to my iMac, paid over about two decades and half. Apple would be a different company, most probably, and would have to innovate as much in the internals of their hardware as they do on their cute outer shells.
I would like that Apple better.
How would Apple fund their software projects if they are given away for free? Hardware sales!
I treat Richard M Stallman’s point of view on software as a necessary extreme, but an extreme nonetheless. It is important to have the entire range of freedom and price represented in all created works, because these prices and levels of freedom represent different target market segments. Having said that, it is very difficult to create any product that is perfect for every person alive.
This is quite a common argument, but it assumes that they would have used the software if the license was GPL and not BSD, instead of developing it in house or finding an alternative.
No, if the Mach kernel was GPL, maybe the graphics drivers would be GPL. But the “GUI stuffs” need not be GPL just as much as Oracle for Linux need not be GPL.
Actually, the kernel of OS X (called XNU, “X is not Unix”) is a mashup of old Mach code and FreeBSD subsystems, and the complete source is available. You can, if you are that kind of masochist, compile your own XNU and tweak all of the build flags. Ditto for a lot of the non-kernel guts of the operating system. Cocoa is
I’m not a fan of every decision they make, but Apple doesn’t “pretend the open source community doesn’t exist”. They’ve hired a lot of FreeBSD hackers. They bought/hired the developer of CUPS (still GPL). They maintain WebKit as an open source project (LGPL/BSD): not only did a lot of code find its way back into KHTML, Google Chrome and many new embedded web browsers are using it as a foundation. See MacOSForge.org for a whole wackload of other open source projects that Apple is behind.
Let’s be real here: Nobody was giving Zed shit for his choice of license. Every so often the guy is on the rag and needs to bitch and moan about how he’s been f’d over (he never seems to consider the fact that he’s a complete douche, and karma has a way of putting you in your place) while shamelessly placing himself on a pedestal. Zed built a straw man to attack in a blog. Don’t feed the fire. Just let it die. Let it die in a fire. His claim to fame is a crappy ruby project that fails just as hard as rails. Now he’s trying to infect the Python community with his abrasive manner. For Christ sake, just ignore this crybaby, please.
Exactly.
Though you are wrong in one aspect – rails does not fail.
You may dislike it, and the community may burn or be full with fights – but it does not fail.
It would fail if noone would use it anymore but this is not the case.
The fact that Qt was able to used in a closed source manner on Linux without being opened up disproves this extremely ignorant statement.
If the Mach kernel was GPL, Mac OS X would not be based on it.
Really, the fact OSX is based on Mach is a historical accident. It is so because NextStep was based on it. Had it not been based on Mach, it would be based on a BSD kernel or NeXT would have developed one from the ground up.
@Magice,
The OP mentioned this, but in your scenario: if Mach was GPL, then Apple would not choose it. They would either (a) roll their own and you would not have your precious I-stuffs for another X years, or (b) choose another and then you would lose any potential development that Apple could send upstream on the kernel itself, which is a win for both Apple and the kernel.
Simply put, BSD gives the developers more freedom, and GPL gives the users more freedom.
“The only way to ensure that you *do* make money is to explicitly dual license, at which point the choice of the free license is somewhat immaterial and you might as well chose the least restrictive one (IMHO, BSD).”
Actually, that’s not quite right. If the free license is BSD, you then have no additional rights to sell. BSD is already liberal enough to be used by a commercial entity without requiring the resulting product be Open Source. When you use the GPL, there are restrictions that prevent someone from using it in their own closed source products…which some companies are willing to pay to make go away.
This is why the one example you’ve given of a dual-licensed project (PyQt) is licensed under the GPL. It just doesn’t work otherwise.
Also-Howdy! Long time no speak. Hope you and Crystal are well.
Hi Joe! Yeah, things are going well. We’re still in the same office building, and Crystal and I moved closer in to town. (You can see photos of my remodel process in the Remodel part of the blog.) How’s everything with you and Charity?
Good point on the BSD + Commercial, I’ll update the text in a bit. Thanks!
“The only way to ensure that you *do* make money is to explicitly dual license, at which point the choice of the free license is somewhat immaterial and you might as well chose the least restrictive one (IMHO, BSD).”
First, I don’t believe dual licensing guarantees incomes since, of course, it’s still possible that no one wants what you’ve produced, at any price or license. It does seem like the best way forward though, and Zed (for one) *is* dual licensing Lamson.
Second, and more importantly, the choice of free license is still greatly material since some of the more liberal licenses (like the straight up BSD-style you are advocating) would allow any “selfish, short-term opportunists” in the community to avoid purchasing a commercial license! I think, quite contrary to your remark, that it makes sense to choose a rather stronger free software license than BSD for the “free” half of a dual license scheme. Specifically, one should choose a license which permits only those uses that one is comfortable sponsoring with one’s “blood, sweat and tears” (as Zed put it). For some (and evidently for Zed) that is the GPL.
I would use BSD if I’m a person coding a piece of software that I want to share but don’t have time and money for lawyers. I also want the right to make proprietary software off of my own BSD software.
I would use GPL if I was a big company that has the money and time for lawyers. I also have competitors that I don’t want to get a competitive advantage from my research and development efforts. I do want to share my code though, even to my competitors because I want to gain market/mind share in my GPL software. For example, I would GPL a hot new printing protocol I developed but allow anybody to make proprietary print drivers, cause I also plan on making money from that. But I don’t want a big company taking my protocol, extending it, and forcing everyone to use their protocol because they have the power too.
It constantly irritates me how advocates of permissive licensing criticise copyleft licences for being “less free” than permissive licences, basing their assessment of freedom on some very narrow, self-serving criteria, and give the impression that the very people who share their work under the GPL are somehow stealing something from anyone who wants to take such works and do whatever they please with them as if they were the ones who created those works in the first place.
The whole point of copyleft licensing is to ensure that *every* recipient has the same privileges as every other recipient, and if that means that someone can’t weld the lid shut on their proprietary product and deny the recipients of their product the privileges extended to them by the people whose code they’re using, then they shouldn’t consider distributing code licensed under the GPL or similar licences. Nor should they complain about it: no-one complains with any credibility that Steve Jobs won’t let them distribute their own top-to-bottom Mac OS X derivative.
In the Python community, I’ve noticed that a lot of people favour permissive licensing based on various assertions about how nice everyone is, although it should always be remembered that the community is a lot bigger than what you see in the public lists and groups, especially when everything is permissively licensed. I’ve never been totally convinced that permissive licences make for more vibrant communities because all the proprietary software businesses can take part: taking part requires such businesses to see the merits in contributing changes back and not trying to outrun the community. I saw interesting work done on PostgreSQL recently, but we may never see the code behind that work; that’s pretty bad when such code is propping up “scientific” publications. There’s also some proprietary stuff that’s appeared at conferences, some presumably unaccompanied by any intent to show the internals to the community in any detail, and that doesn’t necessarily make for high quality community participation, either.
Magice made some interesting points, notably that “in the end, the only thing the BSD ever encourages is the very thing that we want to stay away from!” Permissive licences undeniably facilitate proprietary software, and if you don’t want to help people make proprietary software then you shouldn’t choose such licences: copyleft licences are, after all, a tool to help prevent such outcomes. It’s all as simple as that, and as I noted above, people should be able to make that choice and have it respected, rather than hear whining from people who think that everything in life is played out for their own personal benefit, who might as well demand that the copyright be assigned to them for any given work.
Perhaps hearing such stuff for the nth time was what pushed Zed over the edge – I know I’ve seen and heard this kind of thing all too often in the past – and we even see examples of it in this very discussion. I doubt that such whining is part of “the spirit of Python”, too, but you never know.
“Permissive licences undeniably facilitate proprietary software, and if you don’t want to help people make proprietary software then you shouldn’t choose such licences: copyleft licences are, after all, a tool to help prevent such outcomes.”
This is exactly true. At the end of my post I voice my desire for greater experimentation with other, sustainable economic models for software development that don’t involve a binary split between “everything is free” or “pay me a license fee every year”. Claims that the existence of proprietary software is itself harmful is as unhelpful as Microsoft’s old claims that the GPL will destroy humanity.
“Claims that the existence of proprietary software is itself harmful is as unhelpful as Microsoft’s old claims that the GPL will destroy humanity.”
Here, I get to use the word “undeniably” again. :-)
For proprietary software to be sustainable, it requires a level of custodianship that we rarely if ever see from vendors: a commitment to help users manage the data created and processed with such software, including the migration of data to other solutions, for as long as is required by the user (as opposed to as long as is convenient for the vendor). I’ve certainly seen data stranded in various proprietary software formats and that is a harmful situation created by proprietary software.
Free Software (or open source), on the other hand, undeniably provides end-users with the opportunity to take control of the software they use, allowing them to be the custodian or to appoint a custodian for their systems and their data. The latter aspect of appointing someone is crucial since it is usually ignored or deliberately omitted in the “why would anyone want open source?” advocacy of proprietary software vendors like Microsoft.
“The whole point of copyleft licensing is to ensure that *every* recipient has the same privileges as every other recipient …”
I don’t get this. If mr. X uses component C to make product P, then regardless of the license of P or selfish nature of mr. X, component C remains available to mr. Y and ms. Z. Sure, they may be denied the “privilege” of using a proprietary P, but why would such access be a “privilege”?
Well, by distributing code which uses a copyleft licence (component C), Mr X is obliged to pass on exactly the same privileges (those to run, modify, redistribute with/without modifications) to Mr Y and Ms Z. Mr X cannot have the additional privilege of making product P proprietary software with his special version of component C because this would deny Mr Y and Ms Z the privileges given to them around component C as mentioned above.
One can argue that Mr X isn’t going to change component C and that Mr Y and Ms Z could still get access to it from another source. If component C were licensed under the LGPL, maybe Mr X could still write his proprietary version of product P with careful adherence to the LGPL. In fact, Mr X can licence his own work under whatever licence he chooses, but if he distributes it with (or with the intention of linking it to a GPL-licensed component C), he also has to distribute it under the GPL. In effect, when linking to GPL-licensed works, you are accepting the view that the resulting work must be available under the GPL – that’s the price of entry.
I’m not sure where you get the “privilege of using a proprietary P” from. I was talking about privileges that one gets when one receives a work through a licence, not merely having access to something. By default, if someone produces a work, no-one but the author has any privileges with regard to that work. (I use the term “privilege” rather than “right” because it’s something you gain via licensing, not something you already have.)
I fail to see how a permissive license prevents *all* recipients from getting the very same privileges as every other recipient. They all have access to a public repositary with the code. Some recipients don’t have access to the *modified* code, yes, but again, the derived work isn’t entirely *yours*.
If proprietary product P uses component C’ enhanced from a permissively licensed component C, the recipients don’t necessarily get to upgrade component C’ with, say, enhancements or security fixes from the upstream project or implemented by themselves. Thus, they have been denied privileges that would have been preserved even if component C had been licensed under a weaker copyleft licence such as the LGPL, since this should have asserted an interoperability requirement between the component and the rest of the product.
In effect, the recipients – having received the work encapsulated in component C, plus vendor modifications – are denied the privileges associated with the original work when they receive a closed version in the form of component C’.
I don’t feel the GPL is stealing anything. However, it is a joke to believe that the GPL is about liberty. It is only about restricting the use of data. Data ought to be free.
How does the GPL restrict use of data? Given that the notion of copyleft has withstood decades of scrutiny, you’ll have to do better than this whispering campaign to discredit it, I’m afraid.
@which?
You said: “I also want the right to make proprietary software off of my own BSD software.”
If I understand this correctly, you’re implying that if *you* license *your* code under the GPL, then *you* wouldn’t be able to build proprietary products with it. But it’s *your* code; *you* can do whatever you want with it.
Say I write a checkbook program that I license with GPL. It becomes very popular. It’s so popular than I believe I can add features to it and charge money. It may be my software but since I GPL’d it, now I have to give the source code of those features or I violate my own license. Since it’s my code, I could possibly change the license but then one of the users of my code can take a snapshot of the code when it was under GPL and fork it. Maybe I’m wrong and I can add features and still charge money without giving the source code, but….I need a lawyer to make sure I do it right. If I’m a single person doing this for a hobby, I don’t have the time or money for a lawyer. If I’m a business, well maybe I can.
How can you possibly violate a license on your own copyrighted material?
The answer is you cannot violate your own license. A license is for anyone other than the copyright holder; it licenses someone to use something they don’t own. What you do with your own copyrighted code has no relation to the license you grant to other people. You, as the copyright holder, are above the license.
Besides, if you think about it for even a split second, you’ll see how ridiculous it is to think the GPL could apply to the rights-holder. Who would sue the copyright holder for violating the GPL? Are you going to sue yourself?
@Joe Cooper
You said: The answer is you cannot violate your own license.
I won’t take your word for it unless I get a lawyer.
Look at the fiasco with SQL-Ledger and LedgerSMB. The author of SQL-Ledger tried to relicense his GPL software because of a fork that became LedgerSMB. I don’t know why, but the author “very unhappily” changed it back to GPL (google slashdot relicense SQL-Ledger).
If your software is GPL’d and you have others contributing to your “open source” software with the same license, you could be sued. Again, I’m not a lawyer, but being someone who doesn’t have the time and money for a lawyer, I sure as heck don’t want to risk getting sued because I just decided to relicense someone else’s contribution to my software.
But then that would be the beauty of GPL if I was a big software company that can afford a lawyer. Company “A” decides to GPL software “X” because “A” wants to gain market/mind share on products and services built around “X”. Company “B” doesn’t fear contributing too because they will sue if “A” takes away “B”‘s rights to the code by a relicense. “A” doesn’t have to fear “embrace” and “extend” by “B” either.
You have this “problem” with any licence. Let us say that you release some permissively licensed software and then decide to not bother complying with the terms of that licence for future releases: this would usually mean deciding to drop all the stuff about “redistributions … must reproduce/retain the above copyright notice”. Have you violated the licence? Of course not, provided that all the code was yours. (Note that you’d still need to uphold existing commitments to supply the sources to people if that was part of a licence applying to any prior distribution of code.)
That’s the other aspect of licensing: if you control all the code, you can choose any licence you want; if not, you are bound by whatever licence the community has settled upon, regardless of whether it is “your” project. Saying that only licences like the GPL demand a lawyer to figure this stuff out is misleading because if this is news to you, you’d probably need a lawyer no matter which licence you’ve chosen.
@Paul Boddie
I agree with you on “you’d probably need a lawyer no matter which license you’ve chosen.” I never meant to imply that you didn’t need one for BSD.
But…because BSD is so simple (especially compared to GPL), you can probably get away without a lawyer. If I’m coding as a hobby and want to share, I’ll take my chances with BSD over GPL.
You said: “if you control all the code, you can choose any licence you want;” True, but if you want full control of all the code, then it doesn’t make sense to bother with an open source license, just make your code proprietary.
You continued: “you are bound by whatever licence the community has settled upon, regardless of whether it is “your” project.” And that is true with BSD too, but at least I can take the BSD code and make a proprietary product out of it. The only think I can’t do with the BSD licensed code is claim I wrote it if I did not and hold the author of that code liable for any damages. Say I wrote ALL of the code to a piece of software with a BSD license and then made a proprietary product out of it, I can still say I wrote all the code and I don’t even have to change the BSD license to do it.
If I code a piece of software that I want TOTAL control of, I would make my code proprietary; open sources just doesn’t make sense here. Oh, I probably could make a license that says: “You can look at the source to this software and summit bugs or patches to me, but you have no rights to change the software and you give up all rights to any patches or code you send to me.” Would you contribute to this project?
Out of interest, take a look at: http://www.codexon.com/posts/what-is-wrong-with-gpl. The author makes some interesting points. Keep in mind, I think Zed made some interesting points to in favor of GPL, but I think his problem is a marketing issue, no a permissive license issue.
That is a dilemma. If I GPL something and I accept any contributions under GPL, then I can no longer dual license the project w/o getting agreement from all contributors.
@which?
“If I code a piece of software that I want TOTAL control of, I would make my code proprietary; open sources just doesn’t make sense here.”
That’s not true. You could still have a project which required copyright assignment to get your patches incorporated upstream, just like the Python project does (and it doesn’t use a copyleft licence), and then even licence the code under the GPL.
“Oh, I probably could make a license that says: “You can look at the source to this software and summit bugs or patches to me, but you have no rights to change the software and you give up all rights to any patches or code you send to me.” Would you contribute to this project?”
No. And if the software were available to me under the GPL, and if copyright assignment were required for contributions to upstream, I’d probably not be interested in spending much time contributing. However, I might consider dual licensing my contributions: I retain copyright but let the project use my contributions under some permissive, GPL-compatible licence.
Some people argue that in a permissively licensed project, everyone has their chance to take the project proprietary and that this is an incentive to contribute, which I find debatable, but in GPL-licensed projects with no single owner (such as the Linux kernel) the incentive to contribute is centred upon the guarantee that no-one can take contributions and make them proprietary.
I understand that people like permissive licences because it seems that they do not need to think as hard about the consequences of licensing, but that doesn’t mean that there are no consequences or that one should be unaware of such matters, not least because not all permissive licences are created equal, either.
Within the last decade, there has been a growing disincentive to release code that was not such a factor previously; i.e., software patents.
Numpy & Scipy may not be good counters to Mongrel & Sage as they are fairly straightforward libraries of mathematical functions — “technology” that is not readily accepted as being patentable — whereas the latter two are more web and GUI oriented (of which patent examiners seem quite amenable to granting patents).
Actually, there are a tremendous number of mathematical and scientific algorithms that are vigorously patented. (Marching Cubes comes to mind, for instance.) This is an issue that the Scipy community has to deal with.
Now, it might be argued that because of its more algorithmic nature, the field of scientific computing tends to be less strewn with fluff patent landmines, whereas on the web side of things folks can get a patent for piddly things (*cough* one-click *cough*). But patents are a problem overall for any OSS project, regardless of license.
[…] defense of BSD licenses https://pwang.wordpress.com/2009/07/14/in-defense-of-bsd-licenses/ (response to Zed […]
However, the GPL means that people cannot realistically use SAGE in a commercial tool, either as a platform/runtime, or as an embedded component.
What it is the justification for this claim? Why wouldn’t the GPL allow one to use SAGE as a “commercial tool”?
I think that a GPL program like Sage might well have commercial applications. For instance: you could use Sage for modelling an industrial process. There is nothing in the GPL against that.
You can *use* SAGE in a commercial setting, but you cannot build it into a commercial application without also GPLing the application. Hence my sentence “…use SAGE in a commercial tool”, not “as a commercial tool”.
Does the GPL forbid you from packaging GPLed code into your commercial application and then charging for your commercial application? I think it forbids you from charging for that portion of your application that is GPLed. I also don’t think it means you have to GPL your entire application. There are certainly things that cost money to buy that run on LAMP.
To be fair here, let’s judge the respective license by it’s respective merits.
The practical merits: Which has had more business success? BSD, which came slightly later but had a more mature product, or Linux, which was pretty crappy the first five years? (Or any other two products of your choosing, as equivalent as possible except for the license.)
The business case merits: When does it make more sense to release code? “Let’s give this code to our everyone including our competitors and let them build products on it?” or “Let’s give this code under a copyleft license and create an equal market here?”
Let’s be fair. Python probably matches the former case but GCC matches the latter. Reference code is encouraged by RMS to use BSD (see xiph). The more your code is a product on its own and less a standard platform, the more GPL makes business sense.
[…] In defense of BSD licenses Zed Shaw just blogged about why he uses the GPL instead of a BSD-style license. His arguments for the GPL are […] […]
I’d like to point out that Sage includes many, many components — including NumPy and SciPy — with a number of different licenses: looking through the COPYING.txt file and sources, I see LGPL, GPL, GPL2, GPL3, PSF, BSD, MIT, ZPL, public domain, and a number of modifications of those licenses.
For the purposes of this discussion, I suppose Sage “counts” as GPL’ed, but it is in fact a large, hetereogeneous system.
I’m the director of the Sage project, and I would like to clarify a
possible misconception that the following statement you made might
suggest: “SAGE, an open-source Pythonic replacement for
Maple/Mathematica/Magma/Matlab, is another very successful project,
but they staunchly use the GPL. Their reasoning is much like Zed’s,
because the symbolic math software community has been burned in the
past by people profiting from proprietary extensions of BSD code
without attribution or contribution. However, the GPL means that
people cannot realistically use SAGE in a commercial tool, either as a
platform/runtime, or as an embedded component. The SAGE authors have,
presumably, weighed the trade-offs and decided it’s ultimately more
valuable to be protected than to have the contributions of that
segment of developers.”
This gives us far too much credit. In fact, the Sage project uses the
GPL because every single one of the major symbolic mathematics
programs that Sage builds upon — Maxima, Singular, PARI, NTL, and
GAP — chose to use the GPL (not LGPL) back in the 1990s. If it
weren’t for Sage building on those projects (and their amazing
communities!), Sage’s capabilities would still be quite small in
comparison to Mathematica, Maple, and Magma. Sage uses the GPL
because we have no choice but to use the GPL.
There is a Python project called NZMATH that was started at the same
time as Sage, is BSD licensed, and original had exactly the same goals
as Sage. It continues to be excellent evidence that Sage would not
succeed without building on the great work of the GAP, Singular, PARI,
and Maxima projects. See http://tnt.math.metro-u.ac.jp/nzmath/.
That said, I can understand why you wrote what you wrote above about
why the Sage project uses the GPL. It was because of a discussion
you, me, and several other people had at Enthought back in 2007, and I
don’t want to say that your point is invalid. It’s just that the
situation is really much more complicated than your statement would
suggest. And I was really tired when we had that discussion. Also,
you might recall that I committed to BSD license key parts of the Sage
notebook as a result of that conversation (I can do this since the
notebook is totally independent of that mathematics code mentioned
above).
One can still produce proprietary products that are linked to GPL code. The only restriction is attribution! I don’t have to provide my customers with my proprietary source code, just the source code and attribution to the GPL’d components I’ve used.
I think this was one of Zed’s reasons for choosing the GPL. Some companies were building proprietary applications on his works without any attribution. He didn’t find that very fair and I wouldn’t either. Some people don’t mind gifting software to the world, but some people just want attribution for the efforts. In this case I think it’s a good reason for choosing the GPL.
Permissive licenses are just fine, but I don’t think they required any “defense” from Zed. He wasn’t specifically attacking them in his post. He was specifically explaining his reasons for choosing to GPL his latest project. He shouldn’t have to explain himself, but if he felt the need to do so I’m sure there’s a reason for it… and that’s pretty sad.
He wrote Lamson and wants to GPL it. So what? Don’t like it, don’t use it. Pretty simple.
The companies which cheated on his BSD stuff can just as easily cheat on his GPL stuff. It seems like that was a particularly weak argument from Zed.
“One can still produce proprietary products that are linked to GPL code. The only restriction is attribution! I don’t have to provide my customers with my proprietary source code, just the source code and attribution to the GPL’d components I’ve used.”
Where’s the support for your position in the GPL? You can’t make a work which links to a GPL-licensed component and only provide source code for that component; you have to agree to license your work under a GPL-compatible licence. See this FAQ entry for details:
http://www.gnu.org/licenses/gpl-faq.html#IfLibraryIsGPL
The GPL goes a long way further than attribution. Maybe you’re thinking of the obligations under the LGPL (which coincide more with what you wrote), or those of various permissive licences.
You say “the symbolic math software community has been burned in the past by people profiting from proprietary extensions of BSD code without attribution or contribution.”
(you say the Sage people say this). I think this is FALSE.
As one of the authors of Macsyma, the problem was never one of BSD vs GPL. It was that MIT sought to profit from selling the software that it claimed it owned.
Another major symbolic system, Axiom, was initially sold by IBM, then NAG, and was released as BSD code.
In any case, the idea that someone should be “burned” by another person using what was freely given away, makes no sense.
What is with this entitlement? People with GPL code are granting you FREE USE OF THE CODE. It is free, get over it. You chose to use it.
It is not that free. Here, have a free car but you can’t drive it out of the parking space.
You can do anything you want to the car, but if you modify it you must show the people you pass it on to what you did to it. Remove the seatbelt? no problem! just show the next guy exactly how you did it.
You said:
“It is not that free. Here, have a free car but you can’t drive it out of the parking space.”
And:
“I don’t feel the GPL is stealing anything. However, it is a joke to believe that the GPL is about liberty. It is only about restricting the use of data. Data ought to be free.”
And:
“I’m offended when offered Coca Cola if I must drink it from behind bars. I want liberty not free beer.”
You fail at thinking.
[…] just consider IP Law to have two sides and call it a day for now. And I don’t mean BSD vs GPL. Sheesh. Post a comment — Trackback URI RSS 2.0 feed for these comments This entry […]