News for hackers. Stuff that matters.
Re:The GNU Manifesto Turns Thirty by davidw on Tuesday March 17, 2015 @12:57PM (#9219334)
> understand the hate for GPL

Here's an attempt, although before I start, I don't hate the GPL at all. I think it's a clever hack, and a good license for some situations. Sometimes, as a practical matter, it is annoying:

Sometimes, you work on proprietary code (as to why this is, here's one thing I wrote a few years back: http://journal.dedasys.com/2007/02/03/in-thrall-to-scarcity/ but it's a long, involved discussion in and of itself!) and would like to integrate some small library that would make your life easier. If you can't use it, it's not really that big a deal, but if you can, great. Someone like myself, who greatly enjoys open source software will also be sure to be a 'good citizen', giving back any changes to that little library, even if we're not forced to.

But if it's GPL, you just can't use it. If this is the genuine intent of the author, fair is fair and you move on. Sometimes though, people just slap the GPL on stuff without particularly considering the consequences.

In some circumstances, BSD licensed code can attract more users, because they are able to use it in proprietary applications. If they 'get' open source, they'll still contribute back, causing the code to actually be more used and useful than if it were GPL and excluded from use by a company creating something it wants to make money with. (Ok, yes, you can make money with GPL stuff, but it's a lot more difficult than making money by simply selling something directly, and even that is not easy, as anyone who has tried to start a software business knows).

Re:The GNU Manifesto Turns Thirty by AnthonyMouse on Tuesday March 17, 2015 @02:15PM (#9220033)
> If they 'get' open source, they'll still contribute back, causing the code to actually be more used and useful than if it were GPL and excluded from use by a company creating something it wants to make money with.

It depends on the size of the contribution. If they only fix a small bug then there is no real reason not to contribute the fix.

The trouble comes when a company makes any kind of nontrivial improvement at all. In that case the proprietary version is significantly better than the BSD licensed version and any improvements made to the BSD licensed version can still be incorporated into the proprietary version but not vice versa, so the proprietary version will always be better and continue to gain users at the expense of the BSD licensed version.

Probably the most extreme example of this is iOS. Apple put a slick UI on BSD and now it runs on a billion zero-freedom devices while BSD is slowly dying. Compare this with Linux, which is much more popular in its own right and even more so if you include Android, which itself is much freer than iOS in no small part because the kernel is GPL'd.

The same thing can happen with any BSD licensed software. Anyone can do 25% of the work to create a proprietary version which is 25% better than the original and use it to cart off with most of the original's user base.

Ironically this is one of the things the BSD people complain about: Anyone can take software released under a GPL-compatible version of the BSD license, make some nontrivial improvements to it and release it under the GPL.

Re:The GNU Manifesto Turns Thirty by flomo on Tuesday March 17, 2015 @03:45PM (#9220777)
> Probably the most extreme example of this is iOS. Apple put a slick UI on BSD and now it runs on a billion zero-freedom devices while BSD is slowly dying.

This is a very incorrect association to make, as the existence of iOS has very little effect on the relevance of BSD. (Besides, Netcraft confirmed *BSD was dying long before iOS came out. :)

Sure, from the perspective of 20-30 years ago, there were dozens of proprietary forks of BSD Unix (including NextStep), and BSD looked like a lousy choice for open source distribution.

However that doesn't acknowledge the profound change internet distribution has had on how developers consume open source code. There is now a massive ecosystem of BSD/MIT/Apache licensed code and very few evil corporations sucking it up and turning it proprietary. (Much of this 'framework' code which was always problematic under GPL.) So we should acknowledge that BSD-style licenses are successful in their own right, and not keep relying on outdated FUD about Microsoft or Apple "stealing" code twenty-five years ago, because it largely is no longer happening.

Re:The GNU Manifesto Turns Thirty by AnthonyMouse on Wednesday March 18, 2015 @12:26PM (#9226621)
> This is a very incorrect association to make, as the existence of iOS has very little effect on the relevance of BSD.

Certainly Mac OS X has more relevance to the traditional BSD userbase than iOS, but that's because iOS preempted the existence of a mobile BSD userbase. Linux has not only Android but also a slew of smaller players like FirefoxOS and Tizen. BSD has nothing. It's hard to have less relevance than non-existence.

> (Besides, Netcraft confirmed * BSD was dying long before iOS came out. :)

Of course it was -- it has been under the BSD license the whole time and before Apple it was Sun et al as you note.

> However that doesn't acknowledge the profound change internet distribution has had on how developers consume open source code. There is now a massive ecosystem of BSD/MIT/Apache licensed code and very few evil corporations sucking it up and turning it proprietary.

That is almost a self-refuting statement. The primary reason to want a permissive license over the GPL is to use the code in proprietary software. In some cases that does result in the proprietary software dominating the open source equivalent in the market (as with OS X or Safari/Chrome), and the remaining cases (the framework code you mentioned) are the exact use case for the LGPL, which allows the framework to be used in proprietary software without allowing the framework itself to be supplanted by a proprietary fork.

Re:The GNU Manifesto Turns Thirty by flomo on Sunday March 22, 2015 @12:32AM (#9245592)
> iOS preempted the existence of a mobile BSD userbase

It's completely ridiculous to claim there anything like a "mobile BSD userbase", and zero arguments beyond that were given. There's no real reason why Android or any other mobile OS couldn't be based on a BSD. Given the IP constraints of mobile phones, it probably would be a better choice than a bastardized Linux.

Oh, and "*BSD is dying" is a troll. HAND.

> The primary reason to want a permissive license over the GPL is to use the code in proprietary software.

The facts are that other than primordial forks of BSD Unix (e.g. iOS), 99% of the permissive ecosystem remains non-proprietary.

It's not like people are coding against "Ruby on Rails Professional" or "Angular.js Enterprise-Edition", all of this software is open and commoditized and free, and always will be.

> exact use case for the LGPL

I don't understand why BSD-style is much more popular than LGPL for 'frameworks'. Perhaps because it's because it's the "Lesser" GPL and the first link on the page is "Why you shouldn't use [this]".[1]

In the software industry, the FSF actually has a lot of moral authority. My guess is that if it doesn't look like they'll stand behind the LGPL, why bother?

[1] https://www.gnu.org/licenses/lgpl.html

Re:The GNU Manifesto Turns Thirty by stolio on Tuesday March 17, 2015 @04:31PM (#9221204)
That Apple has a huge amount of mindshare but nobody realizes how much of OSX is based on BSD/FreeBSD is a problem.

The license is a success in the sense that the code is being used, but it's failed to protect the project/brand from a situation where their code is being used worldwide without anybody realizing it.

Re:The GNU Manifesto Turns Thirty by flomo on Tuesday March 17, 2015 @06:30PM (#9222077)
I would disagree. Among the people for which that information is relevant, the vast majority are aware Apple is using BSD.

(In fact the biggest misconception seem to be that Apple is using vanilla BSD or FreeBSD, when it's actually based on CMU Mach/BSD.)

Re:The GNU Manifesto Turns Thirty by stolio on Tuesday March 17, 2015 @07:19PM (#9222325)
Somebody should tell Apple to change their docs then:

> Darwin 1.4.1 is the UNIX-based, open-source foundation of Mac OS X. It is based on FreeBSD and Mach 3.0 technologies and provides protected memory and pre-emptive multitasking. This release corresponds to the release of Mac OS X 10.1. https://support.apple.com/kb/TA25634?locale=en_US

.

> The BSD portion of the OS X kernel is derived primarily from FreeBSD, a version of 4.4BSD that offers advanced networking, performance, security, and compatibility features. https://developer.apple.com/library/mac/documentation/Darwin...

Re:The GNU Manifesto Turns Thirty by flomo on Tuesday March 17, 2015 @09:14PM (#9222917)
I don't believe that disagrees with what I said, but if there's any confusion in terms of how it was worded, thanks for the clarification.
Re:The GNU Manifesto Turns Thirty by stolio on Wednesday March 18, 2015 @12:25PM (#9226609)
Perhaps it depends on how you distribute "vanilla" across the "or"? I read it as "(vanilla BSD) or FreeBSD" but perhaps you meant "vanilla BSD or vanilla FreeBSD"

I don't agree that 'the people that matter know' is necessarily accurate, I also don't think it's sufficient. FreeBSD depends on donations and people donate for a mix of reasons. For example you can successfully brag about donating to "Linux" because even in non-tech circles people know Linux is cool. But even in tech circles people don't know much about FreeBSD.

Not that donations as a from of conspicuous social responsibility makes sense from a rational point of view, but we're humans and there are many situations where we spend money just so people see us do it.

Re:The GNU Manifesto Turns Thirty by flomo on Sunday March 22, 2015 @12:46AM (#9245627)
No, I'm really just talking about common dumb statements you see on tech sites like "Mac OS X is just *BSD with a pretty GUI". When in reality they've been maintaining their own fork for almost 20 years now, for serious technical reasons.

Keep in mind that both BSD Unix and CMU/Mach were funded by the government in order to advance the state of the domestic computer industry. In terms of successful government research projects, these two would have near top of the list!

That being said, it would be great if "FreeBSD" had a bigger brand (and perhaps wasn't seen as Apple's vassal.) But I think that has more to do with the fact that Linux effectively beat them to market versus any license logic.

Re:The GNU Manifesto Turns Thirty by pjmlp on Wednesday March 18, 2015 @10:52AM (#9225867)
So when will Apple make Swift available?

Not that I care, as I don't have any issues with commercial code, but it is a good example of basing work on BSD licenses without giving it back.

Re:The GNU Manifesto Turns Thirty by davidw on Tuesday March 17, 2015 @02:22PM (#9220096)
> The same thing can happen with any BSD licensed software. Anyone can do 25% of the work and create a proprietary version which is 25% better than the original and use it to cart off with most of the original's user base.

I'd actually use Sun and BSD as an example, but yeah, it is a possibility, which is why I am not some kind of anti-GPL zealot. I think it's less likely these days, because the effort required to really run away with a big project is considerable.

Re:The GNU Manifesto Turns Thirty by AnthonyMouse on Tuesday March 17, 2015 @02:50PM (#9220319)
> I think it's less likely these days, because the effort required to really run away with a big project is considerable.

Is it? Obviously the proprietary version has to be enough better to make a difference, but it still actually happens. Look at Konquerer. KHTML was LGPL, so Apple and Google have to release their changes to the engine itself, but not GPL, so Safari and Chrome are proprietary and nobody has even heard of Konquerer.

Re:The GNU Manifesto Turns Thirty by millstone on Wednesday March 18, 2015 @09:45AM (#9225371)
"KTHL is not GPL, so Safari and Chrome are proprietary" gets the consequent wrong. Apple did not decide to fork KHTML and then pick a license. If KHTML were GPLed, Apple would have forked a different project, or perhaps even started from scratch. The end result would have been the same.
Re:The GNU Manifesto Turns Thirty by AnthonyMouse on Wednesday March 18, 2015 @11:24AM (#9226107)
> Apple did not decide to fork KHTML and then pick a license. If KHTML were GPLed, Apple would have forked a different project, or perhaps even started from scratch. The end result would have been the same.

You're making a baseless assertion. Apple ships an enormous amount of GPL software with OS X. It makes no sense for them to write an entire browser from scratch just to avoid the GPL when they're perfectly happy shipping bash, emacs, samba, etc.

Re:The GNU Manifesto Turns Thirty by cwyers on Tuesday March 17, 2015 @02:34PM (#9220207)
> Compare this with Linux, which is much more popular in its own right and even more so if you include Android, which itself is much freer than iOS in no small part because the kernel is GPL'd.

Is it? The Android userland isn't GPL'd at all -- I think the last GPL bit left when they switched from BlueZ to BlueDroid. I don't see any evidence as to why the GPL code in the kernel compels Google to release the Android userland in the Apache license, rather than keeping it closed-source.

Re:The GNU Manifesto Turns Thirty by AnthonyMouse on Tuesday March 17, 2015 @03:06PM (#9220439)
I don't imagine it does. The userland is a whole different thing. But that doesn't mean that I (or Samsung or Amazon or Mozilla) can't make changes to the kernel in ways that aren't possible with iOS, or benefit from Google's improvements to e.g. Linux power management regardless of whether or not my device runs the Android userland.
Re:The GNU Manifesto Turns Thirty by cwyers on Tuesday March 17, 2015 @03:47PM (#9220800)
I'm not sure this is due to the GPL either. Google distributes its patches to MySQL, for instance, despite them running MySQL on their own servers rather than distributing it in such a way that the GPL would force them to.
Re:The GNU Manifesto Turns Thirty by davidgerard on Tuesday March 17, 2015 @05:37PM (#9221714)
They didn't for a while, then maintaining their fork got to be enough of a pain in the backside that they realised that keeping with upstream was probably a good idea.
Re:The GNU Manifesto Turns Thirty by cwyers on Tuesday March 17, 2015 @06:58PM (#9222240)
Pretty much this. GPL or no GPL, there's a maintenance burden when you maintain patches on software when upstream is releasing new code you want that doesn't contain your patches.
Re:The GNU Manifesto Turns Thirty by AnthonyMouse on Tuesday March 17, 2015 @04:14PM (#9221070)
It seems like that is due to the GPL. If they could distribute a version of MySQL with sufficiently useful improvements under their own license then they could charge money for it and go into competition with Oracle. Since they can't do that they no longer derive that possible benefit from denying the improvements to others, so they have a greater incentive to contribute them even if not required to.
Re:The GNU Manifesto Turns Thirty by JoshTriplett on Tuesday March 17, 2015 @01:27PM (#9219612)
I do find it disappointing when someone intentionally makes work GPL without knowing the implications. The intention of GPL is very much to prevent use in proprietary software, and to make life more difficult for proprietary software users, while creating an ecosystem of software only usable by other Free Software. However, even RMS and the Free Software Foundation have explicitly acknowledged that there are cases where an all-permissive license like MIT or (2-clause or 3-clause) BSD makes sense; for instance, when implementing a free format to replace a proprietary one, such as Ogg Vorbis or WebM. See https://www.gnu.org/licenses/license-recommendations.html for instance: "For these projects, widespread use of the code is vital for advancing the cause of free software, and does more good than a copyleft on the project's code would do." (That page actually recommends Apache 2.0 now, which is GPLv3 but not GPLv2 compatible; it used to recommend GPLv2-compatible licenses, and personally I still do recommend using MIT when trying to promote the widest possible use.)
Re:The GNU Manifesto Turns Thirty by nullc on Tuesday March 17, 2015 @01:51PM (#9219818)
Apache 2 is important to avoid things like the situation with LLVM where aggressive patent holders like Apple and Qualcomm feed the project with patent encumbered contributions, so that sorting out what parts of it that you're patent exposed on or not is basically impossible (meaning, you'll take a blanket license at your expense if you depend on it).

If you're not using a more modern license with an explicit patent grant you should at least have some agreement from contributors to make any of their own patents required for their contributions available to all other users of the software and its derivatives. Otherwise you may find that your permissive licensing isn't.

Re:The GNU Manifesto Turns Thirty by legulere on Tuesday March 17, 2015 @02:21PM (#9220092)
http://llvm.org/docs/DeveloperPolicy.html#patents

> If you or your employer own the rights to a patent and would like to contribute code to LLVM that relies on it, we require that the copyright owner sign an agreement that allows any other user of LLVM to freely use your patent.

Re:The GNU Manifesto Turns Thirty by nitrogen on Tuesday March 17, 2015 @03:09PM (#9220457)
A copyright license that includes an explicit patent license would allow non-LLVM users to use the patents as well, as they would need to be able to in order to exercise their rights under the LLVM copyright license and use LLVM code in something that is not LLVM.
Re:The GNU Manifesto Turns Thirty by ucsdrake on Tuesday March 17, 2015 @03:10PM (#9220466)
This is a fantastic example, from both perspectives.

To strictly play devil's advocate for a moment; why do developers think it is appropriate to benefit from the free/open source library, yet not provide that same benefit back to others (in the form of using it in the proprietary software)? To me, this was the exact type of situation in which the GPL was crafted to avoid, and part of why rms didn't just declare his software to be in the public domain. I'd also imagine rms' response to this complaint would be along the lines of, informing the developer in question to work on a free, non-proprietary version of the software, so they could in fact, use the library (totally disregarding the fact it is due to external pressures, such as the employer, that they're developing proprietary software in the first place).

This is, of course, assuming the original developer licensed the library under GPL on purpose and knowing the resulting implications, as you eluded to.

Re:The GNU Manifesto Turns Thirty by davidw on Tuesday March 17, 2015 @04:36PM (#9221245)
> why do developers think it is appropriate to benefit from the free/open source library, yet not provide that same benefit back to others (in the form of using it in the proprietary software)

In the case I'm talking about, the developer uses the BSD licensed library and contributes back to it because they do not want to maintain a bunch of diffs and because they're a developer who gets open source.

Sure, the overall program is closed, but the existence or not of one small part of it was never going to fundamentally alter that.

Re:The GNU Manifesto Turns Thirty by arfar on Tuesday March 17, 2015 @09:37PM (#9223036)
Most likely these decisions are not to be made by the developer but rather the employer who actually own the copyright of the code (assuming they're a standard employee). The question from here should actually be:

Can we rely on a proprietary software vendor to push even minor fixes upstream? From the companies perspective, this is giving away the developers time to competitors for free, basically paying for every competitor to be an a level playing field with you. A companies responsibility is to appease shareholders by making money, not to make good software or help software ecosystems.

I'd say that most likely, yes, developers would like to push all their changes back upstream. Also I think that companies/managers not understanding of OSS would definitely NOT want to.

Re:The GNU Manifesto Turns Thirty by lazaroclapp on Tuesday March 17, 2015 @02:09PM (#9219985)
Isn't this sort of scenario the reason the LGPL exists? That way one can use the library in proprietary projects if needed, but any modifications to the library itself must still be open sourced, under the same license.
Re:The GNU Manifesto Turns Thirty by oddevan on Tuesday March 17, 2015 @03:20PM (#9220556)
The LGPL also imposes restrictions on the finished product, including (but not limited to) requiring the right to reverse-engineer the product so that a modified library can be incorporated.
Re:The GNU Manifesto Turns Thirty by davexunit on Tuesday March 17, 2015 @03:59PM (#9220914)
>the right to reverse-engineer the product

Doesn't sound like a restriction to me.

Re:The GNU Manifesto Turns Thirty by JetSpiegel on Tuesday March 17, 2015 @04:49PM (#9221339)
I think it's an anti-tivoisation clause.
Re:The GNU Manifesto Turns Thirty by davidw on Tuesday March 17, 2015 @02:17PM (#9220049)
Yes, but it was by way of example: sometimes it's not quite so clear cut.
Re:The GNU Manifesto Turns Thirty by lazaroclapp on Tuesday March 17, 2015 @06:09PM (#9221937)
Fair enough. Just pointing out there are three options:

- Let people do whatever they want with it (BSD).

- Let people use it as a library, but force them to release changes to the library itself (LGPL).

- Let people use the software, but force them to release all modifications (GPL).

Neither is good or bad, but depends on the intention of the developer. Also, as a matter of etiquette, contributing changes back even for BSD code should be the norm, whenever there is no reason not to do so. But (L)GPL puts some enforcement power behind that rule of etiquette (and arguably created the norm).

Re:The GNU Manifesto Turns Thirty by davidgerard on Tuesday March 17, 2015 @01:31PM (#9219651)
> Someone like myself, who greatly enjoys open source software will also be sure to be a 'good citizen', giving back any changes to that little library, even if we're not forced to.

And frequently they won't, leading to fragmentation. This happened a lot before the GPL became de rigeur.

Re:The GNU Manifesto Turns Thirty by davidw on Tuesday March 17, 2015 @01:38PM (#9219714)
The trick in this case is for the project to have enough momentum so that you want to try and stay in sync with it and not maintain a bunch of your own changes.

> And frequently they won't, leading to fragmentation. This happened a lot before the GPL became de rigeur.

What time frame are we talking about? My experience was that the GPL probably was at its most popular in the late 90ies, but has gradually declined since then. Most things these days - Rails, Node, Android, Go off the top of my head - seem to have more permissive license.

People are a lot more connected now than even 20 years ago, so contributing back is also much easier. Also, more people get open source, at least for infrastructure type projects.

Re:The GNU Manifesto Turns Thirty by davidgerard on Tuesday March 17, 2015 @02:08PM (#9219975)
I was thinking of quite a lot of the just-before-the-Internet academic software released under a permissive license, which splintered into a thousand fragments.

And Keith Packard frequently regretted X11 being under a permissive license, given how much company forked work the home project never saw code from.

It is easier to give back now, this does help.

Re:The GNU Manifesto Turns Thirty by copsarebastards on Tuesday March 17, 2015 @03:55PM (#9220879)
> What time frame are we talking about?

Try now. Mac OS X is based off BSD and contributes little back (and what it contributes is patent-encumbered enough to be unusable). And that's only a high-profile example which is obvious: there are tons of examples we'll never hear about because we'll never see the code.

Re:The GNU Manifesto Turns Thirty by gillianseed on Tuesday March 17, 2015 @04:49PM (#9221334)
>The trick in this case is for the project to have enough momentum so that you want to try and stay in sync with it and not maintain a bunch of your own changes.

It's not that hard these days, particularly if you are a big company with plenty resources, Apple chose to fork Clang/LLVM so that they could keep their Swift implementation proprietary.

>Rails, Node, Android, Go

Haven't open source frameworks pretty much always been permissively licensed ?

My experience is that applications are typically GPL licensed, meanwhile frameworks and libraries are typically permissively licensed.

Re:The GNU Manifesto Turns Thirty by copsarebastards on Tuesday March 17, 2015 @02:51PM (#9220323)
And it still happens a lot: look at Apple and BSD.
Re:The GNU Manifesto Turns Thirty by davidgerard on Tuesday March 17, 2015 @03:12PM (#9220484)
To be fair, Apple does sponsor FreeBSD, with donations and employment.
Re:The GNU Manifesto Turns Thirty by ljw1001 on Tuesday March 17, 2015 @06:24PM (#9222038)
For me the problem with GPL is simpler. I see a nice little library that someone spent two weeks on. It's GPLd. I would like to use that for the project I'm doing at work, which has 40 person-years of effort in it. So I can never use that 2 week effort code (because I'll be fired). The world is a little worse off because I now have to waste two weeks of my life reinventing the wheel, and so does everyone else who's not doing open source.
Re:The GNU Manifesto Turns Thirty by davexunit on Tuesday March 17, 2015 @07:59PM (#9222551)
I see this argument a lot: programmers working at for-profit companies writing proprietary software feel restricted because they can't use someone else's work to their advantage. Of course, these same programmers don't have a problem with proprietary software licensing. I don't understand this viewpoint. Copyleft software is bad but proprietary software is okay?
Re:The GNU Manifesto Turns Thirty by millstone on Wednesday March 18, 2015 @09:35AM (#9225301)
I have no objection to proprietary software, because that is how people make a living. That proprietary software license is what allowed the author to quit his job and bring it into existence. The alternative to making software proprietary is not making it GPLed. The alternative is not making it at all!

A hobby is not a substitute for a job.

I would never characterize copyleft software as "bad:" the author has donated time and energy, and I am grateful. But it is less useful than it could have been. If you're going to write some software and give it away, man, just give it away!

Re:The GNU Manifesto Turns Thirty by cwyers on Tuesday March 17, 2015 @03:23PM (#9220586)
You bring up a good point. People like to point out that the GPL doesn't prohibit you from selling software, which is true. But it also means that you aren't the exclusive seller of your own software -- if I sell sofware for $1,000 a copy, nothing stops someone from paying me $1,000 and selling the exact same software for $500, $250, $100... even giving it away free. Techinically, you have to buy RHEL from Red Hat. But someone can buy a single copy of RHEL, get the sources, compile the sources (this step is admittedly a lot harder than those three words give it credit for) and give them away free. CentOS used to do this, until Red Hat bought them. (Which puts Red Hat in the weird position of paying people to give the software it charges for away for free.)

There are clearly people who pay Red Hat even though RHEL can be gotten for free from CentOS. Mostly what they're paying for isn't the software, clearly, because the software can be given away for free. What they're really buying is a lot of testing to make sure that, for instance, their enterprise copy of Oracle runs correctly, and someone to yell at if that enterprise copy of Oracle ISN'T running correctly.

Which swings round to what I think you were adressing in your essay -- most software is written by a programmer in exchange for compensation, paid for by people who want to use the software. This is even true, in roundabout ways, for most open source software. (I think it even holds true for Free Software.) Now, the most straightforward way to do this is to have the person who wants to use the software pay for the software. But the GPL makes this more difficult.

A lot of open source and Free Software gets written and paid for in spite of this. How? Because the money-maker is something else. As you say, "In one way or the other, to make money at something in the long run, you are going to have to find and sell a product that people cannot effortlessly get for free." The Linux kernel gets a lot of code paid for by Intel, because it's worth money to Intel to sell x86 processors that people run Linux on rather than buying a SPARC or Alpha or POWER chip (running some proprietary UNIX or Linux, to Intel there's little difference). Red Hat pays for a lot of development on Linux, both because Linux needs to be as good as or better competing *IX operating systems and Windows for its clients to buy it and because having people who write a lot of Linux code helps them when a customer comes to them and needs a custom patch for some part of the operating system. Google pays for open source development because it uses it to run services that it serves ads from and on.

And this has conspired to give the world a lot of software for free (and Free) where the developer still gets paid for their effort. But there are some problems:

1) Sometimes products can suffer from lack of attention until something goes NOTICEABLY wrong. I'm thinking of you, OpenSSL.

2) More broadly, this works better for some things than others. Low-level infrastructure? Plumbing that you can build a service on top of? This seems to work rather well in an open/Free model. As you get closer to user-facing stuff, especially user-facing stuff where your users are individuals and not enterprises, the model starts to work less well. (The notable exception here seems to be web browsers, which seem to be able to produce very good Free and open implementations for end users, so long as they're tied into a larger overall plan of selling those users laptops and smartphones or making money off the default search engine choice for the browser.)

3) There's perverse incentives when the people who use your software and the people who pay for your software aren't the same people. Some of these are actively malicious. Some of them are passive and harder to notice. Free to play mobile games are not open OR Free-as-in-libre, but they are an easy-to-understand example of the problem where your users and your customers are not the same people. In a more relevant example, Google, Facebook and Twitter are all examples of companies who use open software to build closed services, and then revenue is made off selling the users to advertisers. In those cases, there is a tension between doing what's best for the user and doing what's best for the client. Sometimes this is overstated, and I think the overstatement helps some brush off the concern -- you can't let the client win every time, because the client is paying for users and you need to cater to users enough to actually keep them around. But there are times when the tension between who uses your product and who pays for it causes you to make decisions that aren't in your users' best interests.

I think the GPL is useful. Hell, I think it's important. But I also think that there are some significant downsides to the GPL, that it's not a one-size-fits-all solution, that even open source isn't a one-side-fits-all solution, and that making Free versus open or Free versus proprietary into an ideological question has some very real harms associated with it.

Re:The GNU Manifesto Turns Thirty by davidgerard on Tuesday March 17, 2015 @05:39PM (#9221727)
Almost no programmers work on shrinkwrap software.
Re:The GNU Manifesto Turns Thirty by cwyers on Tuesday March 17, 2015 @06:55PM (#9222232)
If I take your literal meaning... I don't think you're right, unless you add the rather large caveat "except for video games." But yes, outside of video games for consoles, most software does not literally come wrapped in plastic anymore. There are still large amounts of programmers who work on software that is sold, though. Office and Photoshop switched from a retail to a subscription model, but it's still the same software being sold to the same customers. The Apple App Store alone made $10 billion last year in apps and IAP,[1] and Google Play is catching up to Apple there.[2] There's also B2B software sales -- Salesforce, Oracle, SAP... all of them sell software. Yes, they aren't shrinkwrapping it, and yes, they are offering SaaS these days, but if you call up Oracle and tell them you want a site license they will totally still sell it to you. So I don't know what you're trying to say here.

1) http://www.theverge.com/2015/1/8/7514457/apple-app-store-rev... 2) http://variety.com/2015/digital/features/google-play-apple-i...

Re:The GNU Manifesto Turns Thirty by nknighthb on Tuesday March 17, 2015 @08:40PM (#9222755)
Your caveat is wrong.

The ESA, which has an incentive to play up the importance of the video game industry, puts the total number of people (not just developers) employed "directly or indirectly" in the US by the video game industry at 146,000[1].

There are around 1.4 million people actually writing code professionally in the US[2][3], even if you limit yourself to the BLS's "computer programmer" and "software developer" categories.

[1] http://www.theesa.com/article/u-s-video-game-industrys-econo...

[2] http://www.bls.gov/ooh/computer-and-information-technology/c...

[3] http://www.bls.gov/ooh/computer-and-information-technology/s...

Re:The GNU Manifesto Turns Thirty by cwyers on Tuesday March 17, 2015 @09:16PM (#9222926)
I think that's still at least an order of magnitude off "almost nobody."
Re:The GNU Manifesto Turns Thirty by nknighthb on Tuesday March 17, 2015 @10:14PM (#9223187)
How low do you think it needs to be?

I'd estimate no more than 1/3rd of the ESA's estimate could possibly be developers[0]. I would certainly consider less than 50,000 out of 1.4 million to be "almost nobody" for the purposes of this conversation.

[0] And I think that's a very, very high estimate, it's probably closer to 1/5th, or even lower. There are a lot of art, QA, and support people involved in the industry, before you even make it to usual corporate overhead of management, HR, payroll, etc..

Re:The GNU Manifesto Turns Thirty by cwyers on Tuesday March 17, 2015 @10:26PM (#9223223)
50,000 out of 1.4 million is roughly 4%. So, yeah, like I said before: about an order of magnitude too high.

But that's really a definitional argument, and those are dull. The larger point is that plenty of people still sell software to other people.

Re:The GNU Manifesto Turns Thirty by millstone on Wednesday March 18, 2015 @10:10AM (#9225547)
The FSF has this bizarre belief that companies write some software, and right before it gets shipped, pick the license under which to distribute it [1]:

When we explain to the employer that it is illegal to distribute the improved version except as free software, the employer usually decides to release it as free software rather than throw it away.

Our hapless employer wrote some amazing software, but then found out that they had to give it away! Hah, joke's on them!

1: https://www.gnu.org/copyleft/