Hacker News Reader

Comment by JohnTHaller | Hacker News Reader

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.

View on HN

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

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.

To me, that says we need more pressure, not less.

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.

> Try explaining that to a middle aged balding manager

Argument through unattractive stereotype?

> To me, that says we need more pressure, not less.

Because more pressure makes us more free, I guess.

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.

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

Wait, when dig GCC come in to this? I'm not sure what GCC has to do with anything else you said.

Companies are people too, you know.

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.

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

You might recall this recent thread: "GNU sed 4.2.2 released, maintainer resigns" https://news.ycombinator.com/item?id=4956899

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.

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

> seem to be at least contemplating the idea that they don't trust downstream users

Or, they don't want to be forced to trust everyone, in perpetuity.

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.

[1] http://gpl-violations.org/

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.

Seems like pretty selfish approach. Not that there is anything wrong with that.

I license under MIT and BSD because I don't want to force people to give back. Often they even do without being forced.

Why do you think it's selfish? Is somebody who sells software selfish? I'd rather say taking somebodies code and not contributing back is selfish...

Taking somebodies code and not contributing back is selfish.

Using the GPL because you want to "get a return on your investment" is also selfish.

So anything but giving things away for totally free is selfish? E.g., the person selling you bread is selfish?

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:

https://en.wikipedia.org/wiki/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".

If you have some time, watch this video on self-interest: http://www.youtube.com/watch?v=URTFDijUEY8

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.

The huge success of GPL software proofs you quite wrong.

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.

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

Heck, even Microsoft has started releasing code under the Apache 2.0 license (e.g., https://github.com/fsharp/fsharp).

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?

No, I am not saying that.

I am saying: don't be naive.

FreeBSD has to beg for funding http://bsd.slashdot.org/story/12/12/09/1726222/freebsd-proje...

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:

http://freebsdfoundation.blogspot.com/2013/04/raise-million-...

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.

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.

But that's been done now. The case has been made.

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

Reply on news.ycombinator.com