MIT and BSD are great for takers who like to take from open source and give nothing back since they are free to take the code, modify it, and release it as commercial closed source software (which is usually what happens). There are rare exceptions to this where people enhance and contribute back. Companies love MIT/BSD since they don't have to give back to their competitors.
The GPL is great as it ensures that everyone who uses my code has to give their contributions back so I get to use and improve upon it, too. Individuals usually like this. Companies often do not.
The way I look at it, I'm doing work for free. The GPL ensures I get a return on that investment in the form of additional code and work that I can use in my own projects and that everyone can benefit from. MIT/BSD lets someone else profit from my work without giving anything back to anyone.
> MIT and BSD are great for takers who like to take from open source and give nothing back since they are free to take the code, modify it, and release it as commercial closed source software (which is usually what happens)
Is this from anecdotal evidence, or have you run some sort of valid study? Because my anecdotal evidence says the opposite.
MIT licensed software gets more power from being used by companies, especially modern startups and software companies, and consultancies. I've had more attention and source contributions from medium-sized companies than from any individual. The usefulness of my library to these larger companies almost ensures its continued survival.
It appears that the rare exception is when companies or individuals don't contribute back.
If it's GPL, then yes, they simply wouldn't use it in the first place. And if your experience is mainly with GPL and not MIT/BSD, then you wouldn't have much experience with companies in the first place, because they rightfully won't touch it.
And as an employee of a company myself, we use MIT-licensed projects only. We're thankful that most these days are. It enables us to use, modify, and always contribute back to the community. In song form: "You get what you give."
The GPL doesn't ensure you get a return on an investment—it ensures that you get only a small sliver of a much larger pie of possible contributions. It's nothing but a roadblock. In short, I really think your assumptions about this are invalid, and based on an idealistic sense of fairness, rather than real-world results which might contradict it.
Edit: furthermore, the original linked study also reaches this same conclusion, albeit in more professional terms. It's a changing ecosystem certainly, but the trend is toward more permissive licenses.
So why is it that Apple, Google, etc are contributing a lot of code back to llvm/clang when they don't have to? Why is it that no one's created a long-lasting fork of xfree86/xorg, even though those are also under permissive licenses? Why is it that there are many commercial consulting companies for PostgreSQL that donate everything they write back to the community? Conversely, why is it that MySQL under Oracle, while GPLed, is criticized for not being open and contributing meaningful information about the project?
There is no business in commercial forks of Xorg because there are no commercial Unices anymore. And their demise coincides with growth of GNU/Linux (as in "GNU userland running on top of Linux-the-kernel").
As for LLVM, the only companies selling commercial compilers specialize in HPC, embedded or other narrow markets and they have no reason to fork LLVM because in their niches they are better. Apple and Google contribute to LLVM because they use it and it benetifts them. And BTW, LLVM wasn't the project which killed commercial general purpose C compilers.
The importance of GPL lies in its ability to "open-source" whole software domains and put them in the hands of their users, at which point the choice of license becomes less important.
Exactly! GPL levelled the field. BSD has been around for much longer than Linux and is very widely used. All commercial Unices and even Windows contain code from BSD but the *BSDs are still lacking contributions and funding. People always complain about RMS' decision to make GCC a complex interconnected bundle. Sure right now it's a stupid decision and the GCC folks have to work on breaking it up. But the decision has to bee seen with the historic context.
But there are simply many people here who think of themselves as hotshot entrepreneurs and take plenty of code without contributing back. I know I know ... they released their implementation of the x hundred nodejs logging library under MIT license. What a huge contribution to society! ...
In the case of a big company they receive contributions, good press, and more important they can retain the power because they are funding developers themselves. If you start your own one person project and Google thinks it is good for their business they can take over it. Yes, the project will retain a specific license but you lost in some way since you can't control the direction of the project anymore.
That happens with GPL products too. Look at CUPS for example. One guy operation, Apple liked it, bought it out. Or a lot of the stuff Cygnus did after Redhat bought them out; the insight frontend for gdb has all but stagnated since Redhat took over. GPL isn't a magic bullet that stops companies from taking over projects.
because working publicly on software is the right way to make software. Try explaining that to a middle aged balding manager who just wants to get through the next quarter without getting canned. You can make an easier case to use permissive software, and once you're using it you can make an easier case to submit public work.
I'd argue that history shows otherwise. GPLv3, with its increased restrictions, proved a bridge too far for a lot of projects, to the detriment of everyone. Apple, the FreeBSD project, the OpenBSD project, etc have all put in efforts to divest themselves of GPL encumbered code because it increased the costs of using the software. Because the wording of things like the patent clauses were so questionable, it became much cheaper in terms of lawyer time, etc, to either use older software that was still under GPLv2, or to use software using less-encumbered licenses, like BSD and MIT.
That balding middle manager needs to make sure that that license is acceptable by his boss, by the people in the legal department, etc. For example, an innocuous throwaway line of a program that can only be used for "good, not evil," ends up needing to get the lawyers involved for clarification and special waivers ( http://dev.hasenj.org/post/3272592502/ibm-and-its-minions ). If the internal costs of using an encumbered program are too great, then chances are, it just won't get used; the company will either write their own version, or use a commmercial variant.
That's well argued. Truth be told IANAL, I know the GPL has being patched to avoid people shirking it's intention. If it became a bit of a monster because of that, I would not be aware.
I mean that in the most genuine way possible - companies are made of people, and people make those choices. Those choices may be "good" or "bad" for the organization.
MIT/BSD give people in those companies the freedom, the respect, to make their own choices, good or bad. That freedom is more free, in spirit, than any of the more restrictive licenses.
There is nobody being bent to your will with GPL; someone who wants to use the code either uses it quietly against the terms of the license, or simply doesn't use it.
Restrictive licenses only close doors, they don't open them.
> MIT/BSD give people in those companies the freedom, the respect, to make their own choices, good or bad. That freedom is more free, in spirit, than any of the more restrictive licenses.
Exactly. The MIT/BSD/Apache 2.0 licenses are about trust and cooperation, not force.
> There is nobody being bent to your will with GPL; someone who wants to use the code either uses it quietly against the terms of the license, or simply doesn't use it.
I've always found it strange that GPL proponents think the GPL "forces" people to do certain things. They don't discuss the option of simply not using the software. Likewise, no one seems to mention the fact that the GPL, as a license, does not (and cannot) "force" anyone to adhere to it's terms; only a court can enforce the terms, and then only if you bring a suit against a violator.
> Exactly. The MIT/BSD/Apache 2.0 licenses are about trust and cooperation, not force.
I see it rather the opposite. With the GPL, you make a piece of software free precisely because you trust anyone downstream, in perpetuity, whether you've met them or not, to make modifications (or not) to the code, to forked versions of the code, to branches of forked version of the code, whatever. The assumption is that each person can decide for themselves whether the software should be modified, and if so, in which ways. They can check with you or with someone else if they'd like, but they don't have to check with anyone before making modifications.
Companies that insist on MIT/BSD seem to be at least contemplating the idea that they don't trust downstream users, and don't want them to be allowed to further modify the software that was originally open source, at least not without separate permission. Hence they appreciate that the MIT/BSD licenses reserve them the right to use copyright law to keep downstream users from making modifications.
> The MIT/BSD/Apache 2.0 licenses are about trust and cooperation, not force.
This is the best description of both the purpose and the result of the license I've yet seen!
To me, it really aligns well with humanity. It matches the way people naturally work with each other. If you have a friend, for example, who always demands fairness with every situation, it can be a true trust mindfuck. For example, people who exactly split the bill at a restaurant down to the penny and the tax percentage based on what you ate. Or, people who will spot you $10 for a movie, but will force you to write an IOU first. I don't enjoy dealing with these sorts of people, since they make the assumption that I am untrustworthy. This is a type of negative reinforcement for your humanity. They make you feel bad simply for doing normal things. This is the GPL in a nutshell.
However, some people are the opposite: generous, giving, and the picture of unselfishness themselves. For example, picking up the entire check at a restaurant, or just splitting it evenly even though they had a smaller dish. Or spotting you $10 and saying "don't sweat it, I know it'll come back around." They make the assumption that you are trustworthy, and understand that you're human and fallible, but have good intentions. They make you feel good about yourself and about them, and you want to be friends with them; it's a positive relationship. This is what MIT/BSD/Apache feels like.
The second person might get burned sometimes by their unselfish generosity, but in the end, they make a lot more friends, and those friends like them and want to give back. Overwhelmingly, they receive more than they give because of the sheer multitude of positive relationships they build.
In the software world, I can absolutely feel this effect. When I see a project that's been GPL'd, I actually consciously and willingly resent them for it. I perceive they're being selfish with their work, they don't trust me to contribute back naturally, and thus they're making a bunch of pre-judgements and demands on me before they hand over the code. It's bullshit. I might use it if I have to, and I'll contribute back because I have to, but you know what? I won't enjoy it. I love open-source, but I can't shake that feeling of ill will.
MIT/BSD/Apache licensed software is the model of unselfishness. It's software being nice to me. It's software that trusts me and gives me the benefit of a doubt. It's software that I want to contribute back to, and I do, all the time. It's software that I choose to use over any alternative, because it's so much lower maintenance. It's software that's fundamentally cool. And furthermore, it's software that's likely to be higher quality, since it's more likely to be used by more companies with real large-scale projects. It's overwhelmingly better in all respects, and I recognize that in no small way.
If you're arguing for the GPL because you don't trust people who use your code to "give back fairly," then you don't get it.
Yes, this kind of behavior that you describe is the reason I personally dislike FSF and Richard Stallman (knowing and acknowledging that they've done more than I can in probably 1000 years, but it doesn't mean they're above criticism).
It cites http://lwn.net/Articles/529522/, which is a living proof of what you're saying. Two main developers of GnuTLS, that had written 10,600 commits out of 11,000 wanted to respectfully part ways with FSF. This is Stallman's reaction:
> Nikos, when you volunteered to maintain GNUTLS, the GNU Project entrusted its development to you. Your contributions so far are appreciated. However, the project GNUTLS does not belong to you.
> If you want to stop doing this job, you can. If you want to develop a fork of GNUTLS under another name, you can, since it is free software.
> But you cannot take GNUTLS out of the GNU Project. You cannot designate a non-GNU program as a replacement for a GNU package. We will continue the development of GNUTLS.
This really ought to boosts the morale of GNU contributers to know that even if they had contributed more than 96% of the codebase, they're still not trusted, and are deemed completely replaceable.
And if they release it, they can be held accountable [1]. Of course, single individuals rarely if ever take action on those violations, but when the copyright for a codebase is possessed by a large body (company/organization like FSF) they may pursue their rights.
You open yourself up to many, many more contributions, because you open it to a much larger audience.
Think of it this way: with the GPL you have 10 individuals and 3 open-source projects that might use your code. They have to contribute all their work back. Great.
With MIT/BSD, you have 10 individuals and 3 open-source projects; plus 1000 more individuals, and 500 companies, plus 50 city governments and 16 universities. Of those, let's assume that 25% are benevolent and would consider contributing back (extremely conservative if you ask me) and of those, let's say 60% actually do. So you get 15% of your contributions back, or 236 people who will contribute, which is 18 times more than the alternative. Yeah I made up the numbers, but even if you only reach a slightly higher audience—the people who would have used your software when it was GPL'd are probably still going to contribute back, so you've likely not changed your overall contribution rate, only increased it, and the only thing you'll have to deal with is some obscure emotional sense that "someone might be using my code and not contributing back", which is an absolutely useless idealism that doesn't produce code, fix bugs, or make your project more popular.
As in social contexts, having expectations of people you deal with only serves as a barrier-to-entry, and doesn't actually change the outcome. It turns our people will contribute back even if you don't force them to. And it turns out that sometimes, being selfish is a good thing. It ain't black and white, and you can swim in the grey area without melting or becoming a bad person. Somewhere in the middle, it works really well, and that's what MIT/BSD captures, in my humble opinion.
It's currently the most popular license, and it had a head start in popularity I think. But the tides are changing, as the original article studies.
I think open source as a concept is successful. Open source encourages community development, giving back to the community, creating things for fun, working on interesting projects, and making things people can use for free. These are all good things that lead to successful projects.
My argument is not that the GPL is unsuccessful—that would be absurd. I'm saying, for a given market, would a project me more successful with a more permissive licence, and thus a broader audience, regardless of whether the majority of users contribute changes back?
It's a complex question and it might vary quite a bit depending on a lot of factors. In my example, you have a largely company-dominated market with few users interested individually. The Rails ecosystem is very similar to this: lots of companies use rails, and the GPL would change that market enormously, in my opinion for the worse. In fact, I'd venture to say that the rise of Ruby and Rails have accelerated our current software boom more than any other projects, if only for setting an example of how open-source and corporate worlds can coexist and reinforce each-other positively. This specific result was almost entirely due to the choice of the MIT license.
In that sense, you could say that the huge success of MIT-licensed software (in many other measures, such as the extremely fast rate that the community grew, the rate of software improvement, the use of the software to create real economic value, and the driving of the growth of the software economy) proves you wrong, also.
Now what if I told you that even giving things away for totally free could sometimes be selfish?
Instead of thinking of "selfish" as the thing you were scolded for as child (i.e., a bad thing), think of it as "self-interested". In and of itself, self-interest is neither "good" nor "bad".
Using your example, the person selling you bread is selfish -- the price you pay probably covers their production costs, plus some additional profit for their take-home pay. If they just started giving the bread away for free (i.e., they're no longer self-interested), you may see that as a good thing -- but what happens when the bakery closes down because it can't pay the bills any longer? Now, you're forced to bake your own bread, at least until a new bakery opens (if ever).
So, to re-iterate my earlier point with this new definition of selfish:
Taking somebodies code and not contributing back is self-interested. Some manager may see this as an easy way to get ahead, without realizing that they may actually be _worse off_ by not contributing back to the project (e.g., the project stalls out and now they're stuck using stale code and trying to maintain things themselves).
Using the GPL because you want to "get a return on your investment" is also self-interested. The self-interest there should be obvious, but for bonus points compare it to the definition of a cartel:
Instead of thinking of "selfish" as the thing you were scolded for as child (i.e., a bad thing), think of it as "self-interested". In and of itself, self-interest is neither "good" nor "bad".
There may be companies which take from BSD/MIT/Apache 2.0-licensed projects without giving back, but I also see plenty of companies who do give back. Examples:
- The Apache Foundation
- LLVM/Clang
- FreeBSD
- Google
Some companies contribute to LLVM or FreeBSD because they are users of this software and sharing development costs with others benefits them.
The story could be different if they were in the business of selling closed-source compilers or OS's. Unix was a legal mess because companies sold their customized forks and fought each other. Linux started as a poor man's clone of Unix but it took off because due to GPL there was no business in fragmenting and killing it.
> Some companies contribute to LLVM or FreeBSD because they are users of this software and sharing development costs with others benefits them.
The story could be different if they were in the business of selling closed-source compilers or OS's.
SQLite project (public domain, which is pretty much equivalent to permissive open source) gets lots of support from people selling closed source work incorporating it. So does BSD-licensed PostgreSQL.
There's actually a lot more incentive for commercial downstream players to contribute to a permissive open source project than a GPL one -- particularly a GPL one that is run by a commercial player and has a copyright assignment requirement.
> Linux started as a poor man's clone of Unix but it took off because due to GPL there was no business in fragmenting and killing it.
I thin the GPL was more important when Linux was first taking off than it is now, because the viability of F/OSS and its utility to commercial players had to be proven, so a license which compelled people distributing work to make it available under similar terms was necessary.
I think the BSD's are not a good example here in general. Most commercial Unices use bits and pieces from BSD without contributing much back. Just look at Linux where companies are forced to contribute back and thus the momentum it gained.
Certainly there are big projects under BSD-style licenses which get plenty of contributions back. But I think it's far more interesting how smaller projects do. For a big project it's in many cases better to contribute back because then upstream has to maintain your changes. Small libraries and tools however are quickly copied and dumped into the code base and nobody even bothers trying to send anything upstream. YMMV
FreeBSD doesn't need to "beg" for funding. They do however, need more awareness about the project to get more people and companies involved.
That story about falling short of their fundraising goal -- I submitted it both here and on Slashdot, not realizing that most people/companies who donate money to the FreeBSD Foundation do so in the last two weeks of the year (for tax reasons or whatever). As it turned out, thanks to the huge amount of traffic they received from those stories, they raised 50% more than their goal and are now funding project proposals, sponsoring conferences, and much more:
I agree that small libraries and tools could be quickly copied into the codebase and forgotten about, but I question whether this is as much of an issue for any languages/platforms where you can dynamically link/load binaries (e.g., JVM, .NET) and you have decent package managers available (e.g., NuGet). In those cases, I think it's so simple to pull in outside libraries and use them that it's just easier for companies to contribute any fixes upstream instead of doing the work to maintain their own separate forks.
Google plays that game because it is an excellent press and can receive zillions of free lines code. But they don't give you any piece of their "cloud machine" just things that don't risk their business. The case of Microsoft is different because the desktop/server/mobile source code is their key asset.
So, what you're saying is: a company could open-source "zillions" of lines of code that are useful to individuals, businesses, and non-profit organizations around the world, but if that code doesn't include the implementation of the company's core business product then it's all worthless or non-beneficial to the world?
> MIT and BSD are great for takers who like to take from open source and give nothing back
This is true in the same sense that a right to privacy and the 5th amendment is good for criminals or that freedom of speech is good for people who promulgate hateful ideologies. Just because a freedom can be abused, it does not follow that it should be abridged.
MORE THOUGHTS: Perhaps I overgeneralized a bit. It does make sense to use a permissive license in certain circumstances. That would be when you need to use something as a component of a larger project. Especially where that component is not a part of your core competency. That's where you'll see lots of companies working together on code that makes sense for them all to use rather than either forking it or closing it off internally.
Where it doesn't make sense is for overall applications or something within your core competency. In that case, you're enabling your competitor to take your business. Unless you're a software as a service company in which case in doesn't apply as much.
Let's take an example. If you're a company that makes a word processor and sells it, it makes zero sense for you to license your work under a permissive license. But, your word processor needs to work with zip files (the open document formats) and security (encryption/decryption). For those pieces, it absolutely makes sense to use a publicly available (and tested/proven) component for zip files and security and to contribute back to said component. This is a place where permissive licenses make a lot of sense.
As for Free licenses, they make sense in certain circumstances as well. Do you think Linux would be where it is today if it weren't for the GPL? Or Webkit (Safari, Chrome, Chromium, soon Opera, etc)? Where you have a whole product and you don't want someone to be able to take the whole thing, add a few minor bits, slap their name on it, and then sell it as if they built it. Or a competitor to have full access to it and be able to improve it without sharing the improvements with you. In this case, having these projects be GPLed helped all of mobile computing (and desktop and server computing as well).
As others have pointed out, I am aware that companies are made of people and will contribute back to software when they don't have to. But, as a general rule, they will only do this when it benefits them, as it does in the above-mentioned scenario around specific components. They generally won't do this when it does not benefit them.
As for my experience, I founded and am lead developer of one of the all-time top projects on SourceForge (millions of users around the world, etc) and we use the GPL license on our core competency stuff (platform and tools). At the same time, we use MIT/BSD/zlib licensed code from other projects for specific components and contribute back our changes under the same license the source project uses.
As for dealing with companies, we have had 2 fortune 500 companies take our software and use it in violation of the GPL and our copyright (that we know of) and use it in commercial projects in an attempt to compete against us as well as dozens of smaller companies and individuals doing the same. None of them had any intention of ever giving back. As a general rule, smaller companies and companies within software that have a reputation to uphold (Apple, Google, Microsoft) are much better at bother understanding and obeying licenses as well as being good open source citizens and giving back.
I think this is the key: different licences for different markets and needs. Linux needs the GPL, Rails needs MIT, not because one license is better than the other, but because each license enables the success of the project within the target market ecosystem.
Perhaps the reasons behind this could be studied more, but I think it comes down to something about how generic the software is, whether it can be extended/used effectively in commercial realms without being unnaturally restricted by the license, and what level/type of contributions are required for the continued success of the project. Both licenses work extremely well for their respective projects.
Similarly, I run a GPL project, and I couldn't imagine using a more permissive license, but the product is standalone and the GPL just works well for the situation. This is all making more sense to me now, thanks for your continued thoughts.
For me, the thing which killed the GPL was the GPL v3.
Not the contraversy which surrounded it, but the fact that GPL v2 is incompatable with GPL v3, and the suggested fix was "make your licence GPL v2+ and trust us for all time to never make a licence you disagree with". I am aware of several projects which will probably never get off GPL v2, and now can't merge in GPL v3-only code (as while the FSF seem to encourage people to make the code forward-licence compatible, they don't seem to encourage backward-licence compatability).
For me (and several minor projects I work on), that was the point at which we just threw our hands in the air -- we didn't have the time or motivation to pick our way out of this situation.
> The FSF drives a hard line sometimes, frankly I think more ire should be directed at TiVo than FSF.
In the first place, IMO, "Tivoization" is an overblown problem ; in the second place, I think the anti-tivoization (and, insofar as they limit the use cases of Free Software, anti-software freedom) provisions of the GPLv3 have done more to prevent GPL usage than to prevent tivoization.
I think it dramatically highlighted the problem with the GPL approach: that, now that the value of open source software is demonstrated, while some people will take and not give back with the opportunity, lots will, and you end up getting more growth of usable F/OSS software if you don't burden the people downstream, and if you try to use compulsion, you get locked in a cycle of increasing the complications and restrictions for downstream users in a way that just gets more people to throw up their hands and not bother with your code at all. While the bad actors find new and creative ways of complying with your most recent license while subverting its intent, leading to yet more complicated licenses, with more burdens, etc.
The funny thing is, in a way, Stallman and Apple agree: users should be able to modify and enjoy their devices any way they like. For the hackers, that means root access. For normal users, that means being able to install apps without worrying about security and privacy. The Stallman model drives the internet's infrastructure, but the Apple model now drives consumer computing. We can argue about the particular provisions (I do prefer Android), but apps work.
I think the GPL was a legal solution to a social problem: companies were hoarding software and trying to patent it. But software patents are still illegal in most of the world, and the best way to ensure software cannot be patented is to publish it under a permissive license, and demonstrate prior art. Regardless of intent, licensing something under GPL is a kiss of death in certain cases, so it acts a bit like a patent anyway: it scares away commercial competitors.
Tivoization is also interesting, because we sort of have a modern day Tivo: Netflix. It's so convenient and affordable, people don't care how the video is being delivered. Instead of Tivo hacking, there's the Netflix API. (http://developer.netflix.com)
The fact is, software- and content-as-a-service have largely made the GPLv3 irrelevant, because the goals it's meant to enable, i.e. freedom and accessibility of software, have been realized in different ways. Society at large simply does not care about a Grand GPL future. It does care about privacy, and being able to export their data from the services they sign up for.
You know, if I make something open-source, it's because I want people to use it. I refuse to use copyleft licenses because all they manage to do in practice is ensure no commercial venture will ever use your code. If I didn't want a commercial entity using my code, I wouldn't make it open-source.
The GPL was created to help free software, which is more about freedom of speech, not open-source. It should be used only when your code is intended as a contribution to the free software movement, not when it is intended to simply be open-source.
> You know, if I make something open-source, it's because I want people to use it. I refuse to use copyleft licenses because all they manage to do in practice is ensure no commercial venture will ever use your code.
Because no commercial venture uses Linux or BusyBox.
> The GPL was created to help free software, which is more about freedom of speech, not open-source.
FSF is actually more about making sure that as much software as possible is "open source" than about freedom of speech. Maybe you confused them with EFF.
Indeed. Part of this for me is vanity in a sense, I'd love it if Microsoft used my code. (Although they never will, but hey, I can dream.) But also, I like permissive licenses because it means I worry less and anyone who uses my code can worry less about it.
Are those commercial ventures linking their code with the Git binary? Or are they just building tools which wrap the command-line Git tool?
I'm inclined to think that most (if not all) commercial offerings are going to use the second option, because there won't be much difference to the end-user and it means the company won't have to open-source their code. If Git was permissively-licensed, perhaps those companies would choose to link with the binary (or incorporate the code directly into their products) and contribute patches and bug-fixes back to the project.
perhaps, I think it's some what of a myth that one can't make money from free software. Sure one can't erect flimsy toll booths and extract rents but as I look around I see lots of companies, .eg. IBM profiting quite nicely from free software.
This is exactly my feeling! A lot of my "playground stuff" is in the Public Domain for this very reason; I hate giving underpants as gifts cause that is such a bummer (and you don't even find out a lot of times until you download the bloody thing), I can't even explain just how bad it feels without coffee first.
The non-playground stuff is MIT (something I did for work) or ISC, which is mostly harmless to anyone who wants to actually use it. People who use GPL are too hung up on controlling the distribution mode of derivatives; I understand the reason GPL exists, but I think it's a faulty premise to begin with.
Kinda like Peace Through Superior Fire Power.
Also, the preamble to the GPL reads a lot like religious/political rhetoric.
On three separate occasions so far, I've come across a situation where someone has rejected a GPL piece (with basically nothing wrong technically; which is a damn shame) only to go with BSD the first time, ISC the second and, to my surprise, a closed source solution the third. Now 3 may not seem like a statistically significant number, but from the type of projects these were, my feeling is that the GPL seems to actively repel adoption to the point where even a closed source binary is more preferable.
The premise is to ensure quality code gets returned to the community, and I understand that, but quality code isn't what we usually get back. When the issue is forced, by and large, I feel people reject participation entirely, return the bare minimum necessary to comply (let's say an API which is GPL licensed while the rest of the library/application is under a different one) or, of course, non-compliance.
It's hard not to be a cynic these days, but I do think most people are basically good. And if you give good people the choice of doing good, they will not only do it, but also do it more earnestly. This earnestness in turn will produce, I believe, code of the best quality.
wow. I honestly thought that when I heard that argument on 4chan, that the people on the other end making that argument were aware how crazy their line of thinking was. This was the last place I expected to see that sentiment reiterated.
You live in a society of laws, that guarantees your freedom. BSD and MIT do not guarantee your freedom. They are free in a purely anarchist sense. This is not a good thing™.
I don't know if the situation is really that complex. The GPL and it's code base exist to push the world towards the correct state of being.
That feeling of wanting to use a GPL library, but not being able to open source your code feels awful, I know, but that feeling is there to get you to ask "Why cant I open source my code?" not "Why is the GPL restricting me?"
I've released all of my open-source code -- with the exception of one project (LGPL, because it was a direct port of another LGPL'd library) -- under permissive licenses like Apache 2.0 or modified BSD.
What I really dislike about that feeling you describe is when I think of a good project I'd like to build, but which would require the use of a GPL'd library -- therefore requiring me to license my code under the GPL. Every time that's come up, I've just opted not to create the project; in my mind, I just can't justify writing open-source code that's "free" instead of free.
> You live in a society of laws, that guarantees your freedom. BSD and MIT do not guarantee your freedom. T
Neither does any license, because licenses aren't laws -- they bind only those people who choose to be bound by them. And that's the big problem with the GPL, it really wants to be a set of laws for how software is licensed (and, from GPLv3, what features hardware is allowed to have, etc.), rather than just a software license, and that doesn't work unless you actually get something adopted by a legislature, rather than sticking it in a license.
BSD/MIT, however, are better at making the software I distribute usable to people downstream, including those who would also share their own work under similar terms. Sure, that also includes those who wouldn't, so with BSD/MIT, the public ends up with potentially a smaller share of a much larger pie than with GPL, but still more given back in total often.
Democracy = freedom to do what you want, as long as you don't infringe on other people's rights/freedoms.
So I think he wants to say GPL is more like democracy from this point of view, while MIT is more like anarchy, where everyone can do whatever they want with it (both good and bad).
> So I think he wants to say GPL is more like democracy from this point of view
The GPL certainly is more authoritarian and less like anarchy, but I don't recall public open-to-all-citizens elections for either FSF leadership or the specific content of the GPL, so its not very much like direct or representative democracy.
More like ideological autocracy, which is great if you agree 100% with both the ideology and strategy of the revolutionary vanguard, not so much otherwise.
Nowadays in the wide I mainly see two use cases for GPL code, either the person want to limit its use to encourage purchase of a commercial license or to prevent its use by a conccurrent, or the second use I see is people wanting to make a political statement of some sort.
I respect both use cases but ultimately I consider GPL code more like teasing to me, because as great as this code is, I know there is some limitations with this code and I won't be able to use it as freely as I'd want now or in the future.
So now, to spare me the mental pain of knowing there is a great GPL project I know I can't use, the first thing I do when I discover a new project is to check its license and if it's GPL I stop reading, plain and simple. I highly respect people releasing GPL code, I highly respect their motivations and somehow their political engagement but I treat it like if this code didn't exist or is a binary.
And for my own code I use the MIT License when I choose to share it with the world.
Most of the work I release is licensed using MIT because it allows other developers to build with my code without limitations or requiring full attribution. I like the idea of anybody having direct access to change or update what I've written to make it better, faster, cleaner.
Until I can find a more "free" license I will stick to MIT as well.
Please don't. Licenses like MIT, BSD 2-clause, etc. are all well-understood by people in the legal profession at this point, while these really add nothing to the table. There's no need for the proliferation of open source licenses.
I like the Apache 2.0 license -- while it's much lengthier than the MIT or BSD licenses, it provides similar licensing terms with the crucial addition of patent protection. If someone submits code to an Apache 2.0-licensed project which is covered by a patent they own, they're required to provide an _explicit_ license for those patents when submitting the code.
In some countries, public domain doesn't actually exist, so software put into the public domain actually has uncertain legal standing there. Better to retain copyright and put a very permissive license on it to avoid ambiguity.
Most people told me it's just not possible from a legal stance, unfortunately. Because honestly I would release most of my works as public domain for people to use as they see fit. Maybe copyright laws will change in the future, but MIT is a close 2nd. Plus it's easy to read and known well among developers(as others have mentioned).
It's important to remember that as well as giving others 'freedom' MIT also protects you from being held responsible for your l33tstrcmp causing a plane to crash in to the ground.
Although there may be altruistic or political reasons for preferring MIT/BSD/Apache style licenses over the GPL, I believe that the choice of license must be closely related to the type of project you are creating. If the project is a library or a piece of code that is intended for use by other developers, you will greatly increase the potential audience for your project by using a license like the MIT/BSD or Apache license.
If however, your project is a complete application (say a code editor, browser, or a game), whose primary audience consists of non-developers, then a GPL can be a good license, as it maximizes reach to your intended audience, while still allowing developers to contribute the project, and most importantly preventing free-riding by potential competitors.
Sometimes I don't care about rights. I care about results.
Considering market size, # of active developers, and general amount of funding (corporate or otherwise), which is the best/most advanced, a major Linux distro or FreeBSD?
The answer to this question will tell you which license has better results.
I don't expect anyone here arguing for the GPL (in an predominately neoconservative community like hacker news). So anyways, I make the conscious decision to use GPL, because it protects my work from exploitation by others (corporations are people too my friend, right?)
I am absolutely amazed by the reactions in this thread. I don't know if HN readers are bunch of neo-cons (I'm certainly not), but I wonder if people feel threatened by the GPL, because they are current or aspirational entrepreneurs who think the GPL gets in the way of their making a lot of money.
I don't think HN readers in general are neoconservative, mostly quite the opposite.
I do, however, think many HN readers have a strong libertarian streak. In this case, when I say "libertarian", I mean true libertarianism (not the "tea party"-ish faction of the Republican party).
In this respect, I imagine most HN'ers prefer the BSD/MIT/Apache 2.0 licenses not because they want to make money off of free software in the future, but because they value personal freedom and extend those beliefs to their own software development. In other words, they want to use free/open software to avoid being trampled on by some company, but they're also not OK with being pushed around by any other "free" software developers.
Read a bit of this article and you'll see what I mean:
"when I say 'libertarian,' I mean true libertarianism . . ."
Talking about "true libertarianism" is no different than talking about "true conservatism," "true feminism," "true Marxism" or anything else -- these terms are all historically fluid, and accusing one another of not being "true" is one of the main activities among communities who unite under the supposed unity of an ideological stance.
But yes, you're probably right in the main about their not liking to be pushed around by others. Still, that describes a vast cross-section of human society.
> I don't expect anyone here arguing for the GPL (in an predominately neoconservative community like hacker news)
HN may be predominantly politically conservative, but it seems a lot more neoliberal than neoconservative.
> So anyways, I make the conscious decision to use GPL, because it protects my work from exploitation by others (corporations are people too my friend, right?)
That is the basic difference between GPL and permissive licenses. GPL is for stopping people from doing things with your work, BSD/MIT/etc. is for permitting people to do what they will.
Another way to think of this: It's alright if you've brought the toys, and you feel the rules to play should be a certain way. It's also alright if you insist on those rules and decide to take your toys home if you don't get to play by those rules. This is pretty much what the GPL is. When it gets obnoxious, is when people start saying that you're "evil" for not using your favorite rules. That's possible, particularly when the complexity of the real world brings pragmatism into play, but it is a bit of an extraordinary claim, especially when put in absolutist terms.
That would be like saying that you're "evil" for playing any kind of ball game without a helmet. This could be a highly beneficial and pragmatic thing in one context (professional baseball) but just silly and obnoxious in another. (Sandlot game with a wiffle ball.)
Stallman and the FSF make the claim that there is a new set of human rights concerning software that we weren't aware of before. That is the crux of the matter. Is it enough to let everything play out "in the marketplace" and let people vote with their dollars and their feet, or is there a new set of rights that should be enshrined in law?
I do think Stallman has a point, and that much good has come of copyleft and activism by the FSF, but does this give someone a right to declare what is absolutely good and evil? I don't think so.
The GPL is great as it ensures that everyone who uses my code has to give their contributions back so I get to use and improve upon it, too. Individuals usually like this. Companies often do not.
The way I look at it, I'm doing work for free. The GPL ensures I get a return on that investment in the form of additional code and work that I can use in my own projects and that everyone can benefit from. MIT/BSD lets someone else profit from my work without giving anything back to anyone.