Less loaded (and more accurate) one-liners might be...

GPL: you may use this code, provided you follow rules representing my views on software freedom.

BSD: you may use this code however you see fit.

Which approach fits with your personal philosophy depends on you. But certainly BSD does nothing to lessen the highly valuable software licensed with it. OpenSSH, sudo, and many others, for instance.

GPL: You can use this software however you see fit as long as you provide the same courtesy for everyone else.

BSD: You can have my labor for free, and then profit off it all you want. Call it free money, you're welcome.

There is an argument that if a high enough proportion of the FLOSS ecosystem's software ends up being adopted into proprietary products, then the community could happily move to using those proprietary products instead and then there will no longer be enough momentum in development of free upstreams and we will lose the "still have FreeBSD" and "still have OpenSSH" cases.

This argument suggested that there needs to be a certain amount of GPL software in the ecosystem to prevent the balance from being tipped this way.

This is my recollection. I have not been able to find any kind of reference to this, but I hope you get the idea.

You're responding to real world examples of copy middle projects and proprietary descendants coexisting happily with vague fears but no examples.

SunOS/Solaris vs the free BSDs?

Illustra vs Postgres?

Oh wait. I found one:

Internet Explorer vs. Mosaic.

As I pointed out in my blog post (linked below), history is littered with the corpses of proprietary spinoffs of free/open source projects. It is telling that the only example I can find currently of a proprietary spinoff eclipsing the open source version currently a) had to be released free of charge and bundled with another program, and b) is now facing renewed competition from free/open source competition in the form of Firefox and Chrome.

So it seems to be an exception which proves the rule. Proprietary spinoffs cannot, in the long run, outrun the community.

This actually seems like a counter-example: the commercial spinoffs have totally dominated in comparison to the free BSDs, which have never had particularly large market share. Through much of the 1980s and early 1990s the free BSDs had approximately zero users, whereas their commercial spinoffs had hundreds of thousands! The BSD licensing also allowed AT&T to reincorporate large chunks of the BSD code back into AT&T Unix (even Microsoft borrowed some of the sockets code for Windows). This situation was only disrupted in the 1990s by GNU and Linux, not by the free BSDs, which re-arrived only later. And even as Solaris declined, the free BSDs didn't manage to capitalize and gain its market share.

On the desktop, of course, a proprietary spinoff of the free BSDs completely obliterates the usage numbers of FreeBSD and PC-BSD: Mac OS X. It's not a pure spinoff; it also includes permissively licensed code from the CMU Mach project, among others. And it's at least semi-proprietary: Apple does release some code, but it's both incomplete and doesn't even build, so there is no free version of Darwin you can actually run.

Yes, they outran them for a while, but the only way Solaris is even surviving at all is because Sun returned it to an open license. How many users are on FreeBSD vs OpenIndiana?

I think Solaris did convincingly outrun BSD. Then they were both killed by Linux. FreeBSD might be doing slightly better on life support, but that is not a great consolation prize, when Solaris did much better in the prime of life. Although I'm not sure even today the free BSD derivatives have more users than the proprietary BSD spinoffs, if you add up AIX, Oracle Solaris, HPUX, etc. QNX and derivatives like Blackberry also include considerable BSD code.

But the question is what you get from proprietary spinoffs. If you are afraid that proprietary firms will drive away the more free software products, then the GPL seems best. On the other hand if you accept that the community will eventually prevail, then you get to see where folks think the market is, and where the community version should go to be more successful.

I wonder how Green Plum is going to deal with a BSD-licensed competitor being Postgres-XC....

There's a lot of software that is licensed under BSD which, for the most part, is sponsored by corporations. If you decided to license the software under BSD (e.g. you and the authority to do so) the likelihood that you're not making a living is relatively small. Because why else would you have released the software under such a liberal license?

GPL: This work must remain in the commons. Any improvements you make must be put back to the commons if you distribute it.

BSD: I own my work. You own your work. You can use my work to create your work. We recommend you put your contributions back into the commons.

In the end, the BSD license does heavily incentivize commons, but it doesn't require them. That's the difference.

But if you don't reciprocate by also dedicating your work to the commons, why should I give your proprietary product a free license to use my product? Being a blue-blooded capitalist, you aren't going to let me use your product for free; why do you expect better terms from me than you yourself are offering? If you expect me to buy a license for your product, it seems perfectly fair that I also expect you to buy a license for my product. The GPL in a sense formalizes that expectation.

(It's worth noting that this line of argument is on quite different grounds than what RMS argues, though. RMS is primarily interested in the right of downstream users to modify their own computer systems, not in game-theoretic choices of software developers.)

Because you want contributions from others and want to work in a vibrant community. And if you are modifying a BSD-licensed project, you probably want to encourage others to maintain your code (what this means is you will, if you want to have a successful proprietary fork, contribute almost everything back, so as to cut your maintenance costs).

> The traditional answer is the capitalist one: because you paid me a license fee. An alternative hippie-ish idealist answer is the "commons" idea: because we both agree to dedicate our work to the commons, and everyone gets each other's work for free.

I think that misunderstands the purpose of the commons. Commons exist because there is value in pooling resources. Commons of course, only work when there are benefits and contributions are aligned. Here, maintenance costs are reduced by contributions, and you get access to the works of others.

Let's look at how this works with regard to PostgreSQL. There have been a number of proprietary forks in the past, including Illustra, Mammoth, Green Plum, EnterpriseDB, and more. In general these have all prospered when they contributed back significant work to the community, but when they didn't they found themselves cut off from community resources. Of these 4, only two are alive today, and one of those is facing renewed competition from free a free alternative (Postgres-XC).

So you have a carrot and a stick. The carrot is that you can make marginal changes around the edges for your target market, particularly if the community doesn't want those changes, and you can release a proprietary product with that, using the work of everyone else. The stick is that if you don't contribute back, you will find yourself cut off from that free labor and in competition with it, and that competition is not one you can win.

> (It's worth noting that this line of argument is on quite different grounds than what RMS argues, though. RMS is primarily interested in the right of downstream users to modify their own computer systems, not in game-theoretic choices of software developers.)

Right, but I am talking about the right of software developers to largely work as they see fit, which strikes me as the best definition I can find. To do this, you have to have decentralized control and a movement away from a corporate-centered model. In this regard, the BSD license is a better and more radical alternative regarding freedom than the GPL is, because it insists that freedom serve practice rather than the other way around.

I guess overall I'd see this as actively harmful. What's important is the rights of users; the rights of software developers to harm users are not rights worth saving. But furthermore as a developer who is not a large corporation, I don't even see the advantage of letting my code be incorporated into the next version of Windows or Matlab or whatever without payment or reciprocity, as semi-frequently happens to BSD-licensed code (there is a ton of it in both Windows and Matlab). Whereas at least a portion of the people who held out for payment have gotten paid (both Windows and Matlab also include quite a bit of licensed and acquired code). If I was a large company open-sourcing a codebase where I wanted to foster a community of other vendors around it, maybe, but I'm not. I'm a person who writes moderate-sized bits of stuff (mostly AI-related) that someone might incorporate into various applications. And if they want to do so, I'd like them to either: 1) reciprocate; or 2) pay me.

But as for the rights of software developers to work unhindered: Pragmatically, I do not think that software developers are, overall, well-intentioned, especially if you consider the overall profit-driven system they/we work within. Hence maximizing their freedom to screw people over is generally a negative, and certainly not guaranteed to align with the freedom of users to work on open platforms. Look at Apple's walled garden as an example of harm that the FreeBSD project has negligently enabled. If anything I think what the BSD license does is remove any restraints on corporations' power, by providing them with unrestricted raw material that they can exploit using their market power without even having to build a big portion of it themselves.

Is freedom of economic value? If it is, then a proprietary spinoff must offer enough value to not only make up for the license cost (vs free download) but also to make up for the loss of freedom.

If freedom is of economic value, then end users can protect their own interests.

With the GPL you have a very different danger, which IMO is actually worse regarding loss of freedom. It goes something like this:

1. Company offers GPL software and sells license exceptions.

2. To do this they require code contributions be signed over to them with exclusive rights and ownership.

3. One day they decide that the GPL version isn't benefitting their business anymore, and they go fully proprietary. They release a new and improved version with compelling features under a purely closed source model.

With BSD-licensed software this can't happen because you can't start at #1.

In general, I think it doesn't have any realizable economic value. Large numbers of users have neither enough control over capital, nor enough organization amongst themselves, nor enough knowledge about software, to wield effective market power. They may realize much later that something they wanted to do is now illegal, and retrospectively regret it or even lobby politicians to do something about it, but they probably won't realize up front that by going to walled gardens there are significant problems.

(This is speaking mainly of regular end-users, not users of specialized software that appeals to techies.)

Then this is where our disagreement is.

> Large numbers of users have neither enough control over capital, nor enough organization amongst themselves, to wield effective market power.

Why is organization required? If you were building a new piece of software, would you prefer to start with open components or closed ones? If you had a business and needed a tool, would you prefer one that could be customized to support your unusual business processes or one where you must structure your business around the software?

In some areas, maybe freedom is not that important (consumer entertainment, for example), but I think you greatly underestimate the value that freedom brings to any productive endeavor.

You still seem to be speaking almost entirely about developers and companies. I care about regular people who use computers, and their freedom to do so. When Apple encumbers OS X, to me that's important, and impacts many people, and to a large extent how society operates. Whether some company building a webapp has a problem with the AGPL, I generally don't care; that goes in the same category of two companies disagreeing over whether a proposed license fee is too high, business details.

As an example of why organization is required: in states which don't ban it, companies are generally able to insert non-compete clauses into employment contracts. This is because individual employees signing employment contracts usually have a mixture of too little individual market power, and too little legal knowledge. The only real way to do away with noncompetes, despite very wide agreement that they're bad, is to either: 1) organize into a union that negotiates better contract terms on your behalf (done in some fields and countries, not in American tech); or 2) pass laws that ban the onerous terms entirely (what California did with noncompetes). Generally, individual contract-signing does not maximize welfare.

I am speaking about people making things. It could be someone building computers and combining software, someone developing software, or a company doing things. However I don't really see a difference here between a company and a household.

Besides, what goal is served by the end user for the right to study or modify code which is applicable to those you seem to believe will never be developers?

Open Source is about businesses and the technical merits of the software being freely available.

IMHO, BSD, MIT/X licenses put developers and their rights first and only then the users.

That's my view of the Free/Open source licensing landscape.

The distinction arises because of differences in motivation. If I distribute the work, I'm obligated to provide the source. If I have made no changes, who cares? If I was able to refuse to provide the source of unmodified builds, users who wanted the source could just get it from upstream. It's developers who want to make changes and refuse to provide sources that wind up feeling like the GPL is meaningfully restricting them.

"Developers often are users too. And many of the GPLs goals seem to have everything to do with enabling the user to become a developer (or hire one, same difference)."

Very true. That's a freedom it's important to preserve.

Also IMO the only way to read the BSD license and GPL v3 as compatible are to read section 7(b) in the GPL v3 as allowing additional copyright license/permission grants beyond the additional permissions section elsewhere. I.e. one must read 7(b) as allowing a legal notice that the author grants rights in a non-removable fashion from his or her contributions (narrowly scoped). Otherwise, the BSD license is GPLv3-incompatible.

If freedom is economically valuable, then folks who proprietize BSD-licensed software can never outrun the community over the long-run, and it also follows that, equally in the long run, more restrictive licenses will have to fall in favor of less restrictive ones.

GPL: you're free to buy a gun, but can only use it in self-defense.

That's why GPL feels "restrictive" - but in a good way - to preserve the freedom of the software in all instances of it.

But network effects themselves discourage fragmentation independent of license.

Or, it may never catch up, if fragmentation (or any other effect) destroys the market for the product in the mean time. I've wondered if that had any role in the rise and fall of Lisp machines; I'm a little too young to have direct experience there.

Failure to do this means you end up with high maintenance costs if you want to pull in enhancements from future versions. So the fragmentation tendency is only partial. You have to either fully go your own way (usually suicide) or you have to give almost everything back (which opens up the possibility of competing with the community).

Sure people may choose unwisely. They will suffer the consequences and maybe learn lessons the hard way. ;-)

And you could argue that being able to keep derivative works proprietary means that BSD-licensed code is more free (as in freedom) than GPL-licensed code. You're free to do whatever you want with BSD-licensed code, including making a derivative work and keeping that derivative work proprietary.

And it's worth mentioning that the GPL only applies until the copyright on the software expires. At that point, the code becomes public domain, and then anyone can do whatever they want with it, including making a derivative work and keeping it proprietary. So BSD-licensed code is a closer approximation to public domain code than is GPL-licensed code.

You are misunderstanding one point, though. Free Software is not about the creator's or the contributor's freedom, it's about keeping the piece of software Free to be modified. And a BSD license does not guarantee that the derivatives remain Free Software, hence that's why it's regarded as highly as GPL in that aspect.

But the question is how much one is encumbering the work of others.

Arguably, the BSD license in this case allows for more freedom in the short term (I can do whatever I want with this software...awesome!). But the GPL license, especially the older ones, helps promote a particular version of freedom in the long run. It's an interesting case.

Why especially the older ones?

I'm not objecting to your claim, I'm interested in your reasoning.

I believe freedom of one person ends where freedom of another person starts. Freedom to steal, freedom to kill, freedom to harm are not seen as positive things. Countries and societies all around the world restrict or forbid them.

Freedom, when out of control, can result in bad outcomes. http://en.wikipedia.org/wiki/Partitions_of_Poland Poland disappeared off the map because nobility and clergy had too much freedom. Most infamous was /liberum veto/ "This policy of parliamentary procedure was based on the assumption of the political equality of every "gentleman", with the corollary that unanimous consent was needed for all measures. A single member of parliament's belief that a measure was injurious to his own constituency (usually simply his own estate), even after the act had already been approved, became enough to strike the act."

Unless you're a hardcore anarchist, you have to draw the line somewhere.

Nobody will disagree with that. The question is where to draw those lines.

> Freedom to steal, freedom to kill, freedom to harm are not seen as positive things.

As Cicero pointed out (in "De Republica"), these things would prevent humans from living together in cities.

I am a classicist. I look back to Plato, Aristotle, and Cicero far more than I do Locke. As far as I see it, the goal of the economy is to serve the household, not the other way around.

> A single member of parliament's belief that a measure was injurious to his own constituency (usually simply his own estate), even after the act had already been approved, became enough to strike the act."

And yet Quakers have shown an ability to make a universal veto work. The key thing though is what you pointed out: universal vetos weaken central authorities and return the power to small regional entities where people can more easily work together. This is a good outcome.

The question really is how to define Freedom. Stallman tries to follow in FDR's footsteps of four freedoms. But in both cases you have logic which then requires centralization as a matter of policy, and then freedom in the service of freedom becomes self-consuming.

Here's my radical idea: freedom requires limits, to be sure, but freedom is defined by the space within the limits. I.e. freedom is a matter of partitioning, physically or metaphorically, something in order to give people a right to control their own space. The freedom which then matters is economic freedom, and by this I mean the right to engage in economic production and trade without micromanagement from outside. To put it another way, it's one thing to have to do the dishes. It's another thing to be told not only to do them but be micromanaged in how one must do them.

Evaluating software licenses from this perspective then gives one the sense that those licenses that the FSF is willing to call Free Software Licenses do not universally as a group deliver more freedom than proprietary software licenses. The AGPL places many more restrictions on products and services delivered with the software than does the license for the Microsoft Visual C++ runtime library when obtained as part of development tools.

So the question is: what can someone produce? What are the limits there? Who is making those decisions? So I side with the BSD folks.

I think it's like snipers in FPS games - the only thing that can REALLY stand up to a sniper is another sniper.

Freedom might mean a lack of restrictions, by defining it as contrast to what it is not. On wiktionary, this is definition #2[1]. BSD is a good example of a license with few restrictions.

Freedom might mean liberty as a philosophy. There it is the is the quality individuals have to control their own actions[2]. Understanding liberty involves how we imagine, and structure, individual's roles and responsibilities in society. GPL is a good example of an license that tries to achieve liberty in today's society.

[1]: https://en.wiktionary.org/wiki/freedom

[2]: https://en.wikipedia.org/wiki/Liberty

Or how about this: imagine for a moment I'm not a programmer. I'm just a poor user, and I take some code under GPLv2, fetching it into /tmp as I usually do. Maybe the code doesn't work straight out of the box, so I search a little and find a hack to fix the code (but I'm still not programming it, just applying random advice from the net). Cool, I get the code working, install it into ~/home/ or /usr/local, whatever. After some days a friend finds out I've got this cool software running and he's not so savvy with the computer but he wants that software.

Sharing is caring alright, so I zip up the binary & associated data files and send them his way.

Whoops, I just violated the license.

The license has a death clause that ends my rights when I violate it.

I'm just a poor user, and now the freedoms granted to me are gone. Or did I really have freedom to begin with?

EDIT: Actually, I'm pretty sure I've violated the GPL this way, more than once. Years ago I ran Gentoo as my main OS, and many of my acquaintances did too. Every once in a while the OS kinda pooped itself and friends asked friends to hand them a copy of a working libwhatever.so.whatever or somesuch. Some of these were patched by Gentoo, some of these might've been altered by me too. Sometimes we shared other binaries that had nothing to do with Gentoo per se.

In any case I never gave these people a written notice saying how to get the source, nor did I host the source for three years, nor did I share the source when I copied that binary to a place where a friend could grab it. I was just sharing. The code is free, right?

Now I know better. I no longer redistribute GPL-anything, because screw all these restrictions. It is not free.

I prefer BSD licenses, to be honest, and anything I write from scratch these days is under those licenses. But there are cases where projects are forked and it is not really possible to change the license.

GPL -- keep it free

The latter allows us to program in 20 years without asking a corporation for permission.

I have BSD-licensed code with copyright notices from the 80s on my system. Yes, I run a BSD.

Life is not that simplistic.

So you wrote a new CRM suite and made it free. This put a bunch of shops out of business, because their clients bolted to your free alternative.

The owners of those businesses have less "freedom" now. So do the employees. But the users of your free software have more "freedom", because they now have more money to spend on other things and make their life better.

Is there some aggregate increase in freedom? I have no idea and neither do you.

Do what you want to do. If you want to write software and make it available for others for free, go for it. If you want to sell it, that's fine too.

But whatever you do, no preaching, please.

NO, they had a rent, and they lost their rent because it became irrelevant. They haven't lost their skills, so they are still free to go and look for other rents to make.

Note that this rarely happens in the actual world. There are tons of products where proprietary offers are better than FOSS tools. That's how can continue being relevant while doing proprietary software. Or, even if you are not "better" than the free software offer, you can offer paid support for your application, etc... and function as a service company and not a product company anymore.

You're confusing free and Free. My job is writing Free Software, but you can't get all of it for zero monetary cost, since it's not online except for clients of ours (and nobody has ever asked us for the source).

If this is actually a problem it all, it's a matter of software with zero monetary cost, which could be true of open source software, proprietary software, and "free software".

Yes there is, for the same reason that the third billy goat gruff increased aggregate freedom by butting the troll off the bridge.

Yes, absolutely. This is something I rarely hear mentioned. Many people consider freedom only as a local optimisation problem. This is why some people argue that the BSD licence, or the public domain, is "freer" than the GPL. It's true that if you receive a program which is in the public domain that your personal freedom is maximised with respect to that current program. It's also true that if you receive a program licensed under the GPL that you have less personal freedom (you now lack the freedom to deprive others of the same freedom you received).

But we can do better than this. Freedom is a global optimisation problem. Locally optimised freedom is called divide and conquer. Copyleft is the best solution that I'm aware of for the global optimisation problem. It should also be noted that copyleft itself only needs to exist in order to "undo" the effects of copyright. Public domain would be a trivial solution to the global problem if copyright didn't exist, or at least didn't exists in its current form whereby it automatically attaches itself to anything and everything. Having a world where both copyright and trivial copying by each member of society exists makes this a non-trivial problem.

>copyleft itself only needs to exist in order to "undo" the effects of copyright. Public domain would be a trivial solution to the global problem if copyright didn't exist

This I must disagree with. In this world of no copyright, how do I prevent people from taking my code, making interesting changes to it, and distributing the binary without sharing what they did?

Copyleft uses copyright to make it against the rules to violate the user's "four freedoms". I don't know whether we'd be better off overall in a world without copyright or copyleft, but there would be no way to guarantee the freedom of your software's future users.

Note that it's perfectly possible to explicitly cede copyright protection by putting your work in the public domain even today. Note that copyleft is nevertheless much more popular for software than "raw" public domain.

Really when you get down to it, the battle is still open source (however you want to define it) vs non open source, and squabbles between copyleft vs permissive can miss the larger picture.

It'd be great if the distinction were merely academic.

Proprietary software takes away your rights <----> permissive <----> free software guarantees your rights

It is about the user, not the developer. The free software movement for the most part sees the power of the developer to take away a users rights as unethical, and does what they can (via copyright) to correct that.

Source code is an oddity, sure, because you can distribute binaries that aren't modifiable and keep the source private yet still have no copyright on anything, but you aren't practicing software freedom. The source code availability is absolutely an extension, but it is no more so one than saying it is unethical to give you a car and never let you see the instruction manual if you wanted to try modding it.