Microsoft: No GPLv3 Software for Windows Phone and Xbox Apps.

>How is that even remotely a good analogy?

Because the GPL binds you to preserve the freedom of your users, too; BSD says "do what thou wilt". Both ways have their advantages.

> Don't like the terms of an author's library? Go write your own then.

I really hate this attitude. Isn't one of the advantages of the Internet bringing developers together to work on things? Can't we put our collective capabilities toward improving things instead of rewriting them from scratch simply because they're not our favorite license or favorite language? Gnote springs to mind.

Edit: Wow, three downvotes within 30 seconds for appealing to working together instead of segregating computing into those who agree with your license and those who do not. This comment wasn't even about the GPL, it was about the OP's demonstrated attitude (and, importantly, not about the OP himself). If you're voting me down, at least man up and disagree with me with prose. It's things like this that make me wonder why I spend so much time contributing to HN.

The problem is that nobody actually knows what constitutes a derivative work. Hence you have the LGPL for libraries so that you don't have to worry about linking them.

The result is that nobody wants to risk tainting their work with GPL code if they're trying to make money. If it's GPL many people won't even look at it because who knows if someone who contributed a 2 line patch 10 years ago is going to come banging down your door with lawyers crying about violations. That's not what freedom is about.

If you want your code to have the widest use possible go for BSD/MIT licenses. If you want to promote RMS' agenda go for the GPL.

How is that any more free than closed-source, proprietary software? You could just as easily say, "Don't like the terms of Photoshop's license? Go write your own then!" And unlike a GPL software vendor, Adobe couldn't turn around and sue you for creating a derivative work (because your brain hasn't been infected by any virally licensed source code).

Anyway, the question of freedom between GPL and BSD is this: Does freedom include the ability to place restrictions on other people? The GPL tries to maximize freedom for everyone at the expense of freedom for each individual (the range of things you can do with GPL software is less than with BSD), while BSD allows the licensee almost total freedom to do what he wants, but doesn't guarantee that the freedom will be spread to others. It's kind of a quantity vs. quality thing.

I feel the same way about the GPL, in that it dictates very strong boundaries about what can and cannot be done with the code you are distributing. I don't personally feel that the tradeoff is acceptable to achieve a goal of preventing corruption, as you say, and it can be argued that the license indeed does prevent many freedoms to do what you will.

If I write software and distribute it as open-source on the Internet, I'm not interested in (a) suing those who don't follow my license to the letter à la gpl-violations.org, and (b) requiring you to release the source code to your product simply because you use mine. For those reasons, I will never apply the GPL to any of the software that I start, period.

It is my not job, as a software developer, to impose my beliefs upon you. The religious fervor in the GPL debates springs an interesting comparison to mind: the GPL is similar to publishing a book about Christ, and requiring those who read it to adopt Christianity. Viral open-source and the majority of the "free software beliefs" are just that, beliefs; I respect everyone's right to believe differently, and I will not mandate a belief in my software.

Why is a negative opinion about the GPL automatically assumed by you to be trolling? It does have flaws, and the GP simply expressed his distaste of them (perhaps not in the best way).

Possibly for the same reason GPL advocates complain about more restrictive licensing than the GPL.

"Hey, why can't I view and improve your source code? No fair!"

"Hey, why can't I improve, compile, and sell your program? No fair!"

disclaimer: I'm fairly license-neutral and think people should choose based on what's good for their project.

The point is that it does take away some freedoms, that the BSD license does not take away.

This keeps getting brought up because people say that the GPL is about "freedom" when the freedom it guarantees is rather explicitly freedom for the code itself at the expense of some of the users of the software. The BSD license does not take away these freedoms of the user - users can pass on the same code to other users with significantly more restriction, but the BSD License itself does not take away those freedoms.

It keeps coming up because its frustrating to hear people making emotional appeals to "freedom" instead of acknowledging the tradeoff for code freedom instead of human freedom they make. Its not that the choice itself is bad, its that not acknowledging it explicitly is disingenuous.

Could you rephrase that in terms that aren't nonsensical in the context of software licensing, such as "bring down the system" and "prevents corruption"?

Possible uses of "free" (as in freedom/libre) ...

There's free for whom/what: - the developer's freedom - the user's freedom

... and there are also multiple time-scales of "free" (much as there are multiple timescales of "wealthy"): - free for me proximally (when I've already got the code) - free for me in the more distant future (when I might not)

For users, the GPL ensures both free-now and free-later. For developers, one could argue that the GPL makes the trade-off of reduced freedom now (freedom to do what you want with the code you've currently got) for more freedom later (freedom here to at least get the code and then do what you want with it).

The strong case-in-point here is when a developer modifies some code, and then releases it, and would like to have the freedom to later build on contributions by others.

Is the trade-off worth it? This is now something of an empirical question.

I was not trolling. The GPL nominally stands for freedom but yet the means by which it forces restrictions is the opposite of freedom. I say if you want people to do something, do so by setting an example, not by writing weasel-worded legalese that ties peoples hands. Write code, release it under MIT, and let people do what they want with your code, and by doing that you're setting an example and encouraging others to do the same. You'll also encourage participation by businesses who would like to make use of your code in their proprietary system and everyone benefits when they contribute back because they don't have to worry about the stringent restrictions of the GPL.

Share-Alike licenses like the GNU GPL are excellent licenses and are worthy of consideration for whole categories of software.

What they aren't, however, is 'free' by any rational or sane definition of the word. They impose restrictions -- and carry those restrictions downstream -- on the use of the software that increases the theoretical range of people who would do things with the software. But those restrictions in and of themselves do not increase "freedom" for anyone.

Like I said, there's good reasons to choose these sorts of licenses. What I object to are the semantic games and occasionally outright lies and histrionics of GNU GPL supporters.

"The freedom that the GPL takes away is the freedom to bring down the system. It keeps people in check and prevents corruption."

Sure, a license will ensure that people cooperate, write good code and are interested in the quality of a project.

Do you really think that the reason that people are doing this is mostly an implication of a license?

Because freedom also means freedom to use my code and keep it to yourself if you want to. There isn't any corruption in that. Tons of software here are using bsd/mit licensed code and not releasing their change, that has nothing to do with corruption (or you don't understand what corruption is, go read a definition).

Using the GPL means you're free to use my code ... As long as the result is under gpl too. You lose your freedom to chose a license. You lose your freedom to keep changes to yourself if you release the resulting binary (why ? because you want to). You lose your freedom to use other piece of code that are not gpl compatible.

I have nothing against the gpl and I use tons of software using it, but it is a fact that it cuts down some of your freedoms compared to other licenses.

That article is too riddle errors to be great. Consider his paragraph on OOXML. He says that ODF does the same work as OOXML in 1/10th the size.

First of all, it does not do the same work. OOXML includes hundreds of pages covering spreadsheet formulas, giving mathematical definitions of them, sample input and output, and detailed descriptions. ODF omits spreadsheet formulas. ODF, as passed by ISO, barely deserves to be called a "specification", as there is virtually no chance that two people independently implementing from the spec alone would come up with interoperable documents. It is more accurately thought of as a guide to help understand the OpenOffice source code--which is what you actually would use as your spec if you were trying to write a real-world ODF application.

Second, even for those areas where they do the same work, the OOXML spec is more precise. That accounts for much of its size. For instance, consider how dates should be stored. Both ODF and OOXML list specific calendars that must be supported. In the ODF spec, this is a simple list, just giving a short informal name for each. In the OOXML spec, they give a table that gives the short informal name, but also gives the full official name, along with a complete citation to the official definition of that calendar.

Or consider password protected documents. All ODF tells you is where to store the password. (It might also say it should be hashed). OOXML covers that, but also tells you what hash formats and encryption systems must be supported, and for each of those cites the appropriate standard.

Ah, but that's the thing - it is a trade-off. While both the GPL and BSD (and other Free Software licenses) are certainly better than closed-source, the GPL is a promise to the user at the expense of the developer (a reasonable expense, to be sure), whereas the BSD and BSD-like licenses are promises to the developer, perhaps at some expense to the user (i.e. if something uses it it's not guaranteed to be Free Software).

Given that most people are developers, not users, I myself prefer BSD-style licenses. That said, I also think the GPL keeps developers honest and is healthy for the FOSS ecosystem as well.

s/languages/licenses/

1) Google Nexus phones do come with this as the default.

2) For many Android devices (kit from MOT excepted), the hacks are pretty trivial. I suspect the protections on HTC phones are more of a "Warranty void if removed" sticker than something to really bar you from gaining root.

It's still a brass bitch to run anything that isn't a simple apk with restricted permissions on a non-rooted phone.

This is useful, and I think more of what the OP was looking for.

Read one, and you've read most of the rest. I've thought about reading one carefully, making notes, and running a diff on new ones.

Saves time and avoids risk.