Why is FreeBSD deprecating GCC in favor of Clang/LLVM?
unix.stackexchange.com
unix.stackexchange.com
In fact, the error messages of the two systems are largely a tradeoff at this point, and in a project I work on that compiles using both gcc and clang (targeting MinGW and OSX) simultaneously, on multiple occasions gcc has returned the more useful error messages (even if you discount the times when clang outright crashes while trying to compile my code, something gcc hasn't done to me in a decade). Even to the extent to which clang is better (which is mostly how it will guess what you meant and then compile the rest of the file under that assumption), it is kind of insulting in an open source context to treat that as a competitive advantage when I'm certain gcc would have loved that patch as a contribution.
This. As stated in the accepted answer in the linked article, licensing issues are the real reason. Technical differences are ephemeral. The competition between GCC and LLVM has a habit of inducing improvments in both projects. By all means, at any given point in time one project can have an edge over another in this niche or that edge case. But fundamentally this is a philosophical divide between Free Software and Open Source Software.
GCC uses a copyleft license; LLVM/clang uses an all-permissive license. FreeBSD prefers to avoid dependencies on copyleft code, especially in their core; thus, they naturally prefer LLVM/clang.
This essay covers the essential differences:
What you're thinking about is the fact that the "Open Source Movement" (and its formalization in OSI) were created largely to decouple the FSF (really RMS specifically) from the broader movement and remove his status as a default evangelist. Whether this is a good or bad idea is a flame war for another day (and it's been had more times than needed over the past 15 years), but it has absolutely nothing to do with the content of the licenses.
"It is that, whereas free software is always also open source, open source software does not necessarily have to be free software. That is, software can be open source without granting its users the additional freedoms that free software guarantees."
This is incorrect, and the example given was incorrect. The terms are identical in meaning. Open source was coined to be a trademark for free software.
Second, the Tivoised BSD code is free software. The fact that a piece of hardware exists that refuses to run a modified version of some BSD licensed code, does not make the code non-free.
https://www.gnu.org/licenses/rms-why-gplv3.html
Quoting the relevant bits about tivoization:
> The manufacturers of these computers take advantage of the freedom that free software provides, but they don't let you do likewise... Freedom means you control what your software does, not merely that you can beg or threaten someone else who decides for you.
- GPLv2 is free software https://www.gnu.org/licenses/license-list.html#GPLv2
- If I take the Linux kernel 3.10.6 and create a piece of hardware that refuses to boot up any other version, Linux kernel 3.10.6 is still free software.
I think your argument is really with the FSF. There was no shortage of drama when Linus refused to upgrade the Linux license to GPLv3.
Tivoization removes the freedom to modify your software (and still have it run). Again, quoting the FSF about tivoization:
https://www.gnu.org/philosophy/free-sw.html
> Freedom 1 includes the freedom to use your changed version in place of the original. If the program is delivered in a product designed to run someone else's modified versions but refuse to run yours — a practice known as “tivoization” or “lockdown”, or (in its practitioners' perverse terminology) as “secure boot” — freedom 1 becomes a theoretical fiction rather than a practical freedom. This is not sufficient. In other words, these binaries are not free software even if the source code they are compiled from is free.
I don't know what else to say. The FSF writes, "these binaries are not free software". They're referring to Tivoized Linux binaries. They get to make up the rules here. That includes changing their mind about freedom such that something that was formerly totally free is now less free.
FWIW, I'm not advocating for or against GPL software.
No, it's not "their" term. They didn't invent and trademark term "Free". People were always using this word in context of software to mean that something is free of charge, and that is still the major usage of the term if you go asking users of the actual software.
I don't care about FSF at all, but it bothers me when people assume that "free" could only possibly mean "Free (tm) (c) FSF". The term existed long before FSF with completely different meaning, which is still retained by >90% of the users.
It's only the developers (and lawyers) that argue whether GPL, BSD, MIT or any other software is "free", free or not free. The users call it free if they can use it without paying for it, and that's all that matters to them.
</rant>
Of course the free software movement doesn't own the term 'free', but context matters.
Personally I'd call it a divide between "Free" Software and Free Software. The GPL's style of bringing freedom to the world reminds me of Operation Iraqi Freedom...
For instance, there are laws constraining doctors from releasing sensitive medical information about persons for the greater good of society at large (since people should therefore not have to worry about their doctor leaking news of their embarrassing disease they are being treated for).
Something as simple as everyone paying taxes to provide for things such as air quality testing so we don't end up like Beijing are another example, along with mandating carbon controls so that we can at least try to arrest runaway greenhouse effect that would cause global warming down the road.
Sometimes long-term freedom does require constraint on permissible action. Sometimes it doesn't. But it's not sporting to compare someone who tries the former route to invading a country IMHO, even if you personally feel the latter is better.
mpyne nailed it. If anyone is looking for further discussion of this concept check out "Social Contract Theory."[1][2]
[1] https://en.wikipedia.org/wiki/Social_contract
[2] http://www.iep.utm.edu/soc-cont/
Sidebar: It doesn't hurt that you get to say cheeky things like "Before the GPL life was nasty, brutish and short."
... never mind that GNU was around for 6 years, and BSD was around for 12 years before the GPL was published.
The BSD license clearly derives from the MIT X license (1985 at the latest) rather than the GPL.
Berkeley's code in 4.3-Tahoe (1998) used the BSD license (with slightly different formatting).
How is that relevant? Running linux requires paying multi-dollar prices to buy a computer; does that make the software any less free?
Thomas Hobbes famously said that in a "state of nature" human life would be "solitary, poor, nasty, brutish, and short". In the absence of political order and law, everyone would have unlimited natural freedoms, including the "right to all things" and thus the freedom to plunder, rape, and murder; there would be an endless "war of all against all" (bellum omnium contra omnes). To avoid this, free men contract with each other to establish political community i.e. civil society through a social contract in which they all gain security in return for subjecting themselves to an absolute Sovereign, preferably (for Hobbes) a monarch. [1]
Hobbes/Locke/Rousseau's social contract is similar to mpyne's "Sometimes long-term freedom does require constraint on permissible action."[2]
[1] https://en.wikipedia.org/wiki/Social_contract#Overview
[2] At least in my reading of his comment, it is entirely possible that he thinks I am a crackpot and completely missing the point.
Sometimes I like to think of it as the problem with local minima/maxima preventing an optimization algorithm from achieving the global minima/maxima, except applied at large.
Put in the context of computer software licenses, one should simply imagine a world where all software were BSD-licensed and then see if open-source as we know it could feasibly continue. Certainly it would in some areas, but eventually if a given open-source project were consistently out-competing a proprietary product, the business being disadvantaged could fork the whole thing at once and turbocharge its now-proprietary development for long enough to supplant the old, open version.
Witness what Nokia did with Qt. They poured tons of money into it and turned it in a short time into a mobile-class toolkit that was even more the "Best of Breed". They had so much resource investment that they were able to relicense the whole thing from GPL/QPL to LGPL/QPL. That particular case has turned out alright, but it should be illustrative of the danger of a world with a weak F/OSS ecosystem.
Given all the problems we still have with software patents and other IP shenanigans I simply can't rest on the idea that the mere technical superiority of development "in the open" must necessarily and inevitably lead to a world where software is open and available to the users who would need it, without the judicious use of copyleft licenses in the mix along with BSD/MIT-style licenses. They both have their place.
Whether those changes would have been made free if the original code was GPL-licensed is highly debatable, and there are plenty of examples on both sides. Notably, there was more or less no way MacOSX would have been built on GPL code. Conversely, many router projects have been forced to release source code due to being based on GPL-licensed Linux code.
When a library is under BSD, for example, and is compiled into a program statically, it does not matter at all whether the developer using it was kind enough to provide the source code to all of their modifications: from the perspective of the user of the binary the freedom to change the software they are using has been lost, even if they are a developer. This is what the LGPL guarantees: not directly that the source code is available (though it does), but that any binary distribution that uses the library also provides the means required to replace the binary of the code with a modified version based on the source.
Moving to the full GPL, what is gained is the "viral" guarantee that this ability to get the source of a binary is maintained as people attempt to use the benefits of the licensed work in a larger binary. The license, philosophically and legally, is not about a property of the source code: it is a property of the binary being distributed; the result is that people who rely on the works of others in their binaries have to make the entire binary open and modifiable to end users. That's what makes GPL so interesting: it is a license about binaries and what the rules are surrounding how people can modify those binaries, and is only tangentially related to source code as the means by which these binaries will be modified.
Of course, as TiVo taught mainstream, there is a loophole: you can comply with GPL2 fully and yet users are able to lose these guaranteed freedoms if the binary software is verified by some kind of hardware lock: Android being open source is academically interesting, but provides no value to the owner of a device with a locked bootloader; GPL2 required the binaries to relate to source code in ways that failed to take into account cryptographic verification by unmodifiable firmware. This is why the GPL3 exists: to provide this freedom of modification to the binaries sitting on my hardware devices, and effectively moves the freedoms being guaranteed from the "binaries" all the way to the product itself.
At the same time, users of the fork still benefit from the original code that exists in the new project, as there is no need to rewrite it. That effort can then be made to make the new project better. There may not be as much of a benefit as there would be if the fork was also open source, but there's clearly still some benefit if users find it useful enough to use it.
Now, an argument can be made that the ability to fork the code may prevent people from contributing to the original project. In practice, maintaining the diffs for any reasonably active project is a lot of work, and it makes sense to contribute as many changes back as possible, leaving out only the 'secret sauce' bits, just to reduce the amount of work necessary to maintain the fork. Those proprietary bits might have made it into the original project if it were using a copyleft license, but they also might not have been made at all.
To the user of this binary, your arguments about potential benefits to an upstream open source project are thereby off-topic (especially if the source code is fully available and no one is hiding any modifications) and your discussion of "forks" is downright nonsensical: given 100% of the source code of the software running on a TiVo, you still have no freedom at all to actually modify that software. The system is "open" in some weird, mostly academic fashion, in that you can easily find out how it works, and maybe you could even build a TiVo competitor based on it, but to the owner of a TiVo--an actual user of the distributed binaries--the source code is worthless. The GPL's purpose is to guarantee that a user of a binary will always have the freedom to change the functionality of that binary in the context of their use.
This is a fundamental freedom of the user that requires the developer to give up some freedoms with regards to how they deploy their binaries and has nothing to do with projects and forks or even source code in any direct way. This is a trade off related to a subjective understanding of "freedom" as it applies to different actors in the system, and so to understand why the GPL is interesting you have to be willing to temporarily take off the hat of a project maintainer and put on the hat of a user, as the GPL's purpose (and yes, this is somewhat sadly ironic) is to protect the rights of a different player in the ecosystem than the maintainer whose job it is to choose a license for their project.
The GPL doesn't guarantee that a potential derivative work would be open source. The developer that might have based their work on open source might choose not to use the code of the original work in their project so as to avoid having to make their own work open source as well. This is a loss to the world, as the quality of their work would most likely not be as good, either because the code wouldn't be community reviewed or simply because time was spent writing code with functionality that already exists as open source taking away time from other features.
GPL or BSD, somewhere along the line, the developer has to willingly make their work open source. The only case the GPL can force someone to make their work open source is if someone has used GPL code with the intention of violating the license, but are later exposed to have used GPL code and are shamed into open sourcing it.
At the end of the day, the user only has freedoms to the code that the developer chooses to grant. Whether this is by choosing to use GPL code in their project and making it GPL as well, using BSD code in their project and making it BSD as well, or not using GPL code (but possibly BSD code) and not making their work open source.
In that regard I think even GPL advocates would be quite happy to use your example about Darwin, at least as a cautionary tale (though perhaps there was more benefit for the BSD upstreams than I am aware of; we're still waiting for an open release of ARM Darwin...). Likewise Apple's adoption of KJS/KHTML didn't go as well for KDE as we had hoped.
Then what's the difference between the two terms?
I've always thought that they were quite different (RMS vs ESR). Especially when capitalized as pronouns.
Edit: Nevermind. I missed ajross's response.
The more relevant one for the current discussion: people who use and identify with the term "Free Software" generally care about software freedom as a valuable principle independent of its practical benefits (in other words, software should be free because it's wrong to restrict developers' ability to use, copy, modify, and distribute it), while people who use and identify with the term "Open Source" generally care most about the practical benefits (software should be open because that's the most effective and efficient way to produce software). There's a great deal of overlap between those two communities, but in general those two terms imply a different set of underlying principles held by the speaker. People who want to be all-inclusive sometimes say "Free and Open Source Software" or FOSS.
The origins of that distinction come from the original creation of the term "Open Source", often described as a marketing campaign for Free Software: the term often helps win over people (and businesses) who are unconvinced by software freedom as a principle but highly convinced by the effectiveness of Open Source as a software development model.
In terms of literal definition, Free Software is defined by the Free Software Foundation's "four freedoms" (https://www.gnu.org/philosophy/free-sw.html): use/run, study/modify, redistribute, and redistribute modified versions. Open Source is defined by the Open Source Initiative's Open Source Definition (http://opensource.org/osd), which in turn was derived from the Debian project's "Debian Free Software Guidelines" (DFSG, http://www.debian.org/social_contract). In practice, almost every license that passes one definition passes the other; it's exceedingly rare to find a license that's actually Open Source but not Free Software or vice versa.
Also worth noting: both terms are unfortunately ambiguous, in that "free software" (especially when not capitalized) can be confused with software available for no fee, and "open source" can be confused with software with source available but not under an Open Source license.
There is a subtle distinction. Open Source is generally in favour of developers' freedom, Free Software is generally in favour of users' freedom. These come into conflict when, for example, developers want to lock their users into SaaS walled gardens. Open Source advocates are generally in favour of the developers' freedom to do this. Free Software advocates are generally in favour of the users' freedom to not be locked in (see the AGPL for example).
Hardly the case when you want to extend/embed your compiler frontend/backend. In this case, LLVM/Clang shine. They are written in fairly clean and comprehensible C++ libraries. Most CLI tools are well under 1k lines! GCC is a real pain to even comprehend, let alone extend/embed!
If you think this is good/bad for Clang/GCC, depend if you ever used said features, or if one prefer a smaller compiler which has less features.
Even if GCC had very clean separation between the steps, the FSF's interpretation is that you couldn't use the GCC parser for something like highlighting/suggestions the way Apple does in XCode without making all of XCode GPL.
It's a perfectly fair interpretation. I think making the opposite case would be quite difficult. But it shouldn't be surprising that Apple wouldn't want to open up all of XCode. I also don't blame Apple for not wanting to continue to re-implement parts of GCC and try to stay bug-for-bug on parsing when the only reason you can't re-use the same code is licensing.
Only in this one technical implementation you've imagined. Interacting with GPLd tools via basically any method expect actually linking it into your code (e.g. pipes) doesn't infect your code with GPL obligations. Presumably just piping the entire code to gcc -fdump-tree-original every keystroke would be too slow but you could probably get it working nicely if you had the sort of engineer time Apple do.
GCC, on the other hand, seems to have a much narrower focus but with a lot more optimizations and weird extensions.
http://gcc.gnu.org/onlinedocs/gccint/Plugins.html
The wiki has links to some plugins too http://gcc.gnu.org/wiki/plugins
I heard GCC is partly a bit of a hairball to prevent GPL loopholes. They wanted to ensure you can't wrap it in some kind of RPC framework to get around the GNU GPL. They might clean things up a bit, if there's no longer an incentive for people to want to effectively steal it (since they can just use Clang instead).
In fact, open source projects (even GLP ones) might start switching to Clang, if it has a cleaner API.
So the costs of a hairy API are going to start outweighing the benefits.
Even if it that doesn't hold true anymore, I think it's valid to highlight since it's one of the motivations, probably one of the original creators' pain points with GCC.
The website reads:
Some of the goals for the project include the following:
End-User Features:
- Expressive diagnostics (examples)The sales catchphrase superior error message is still true for the people in the market. And comparison with compiler in GPLv3 is meaningless to them.
You're just out of target.
This is the latest version available by default on MacOS and FreeBSD (for licensing reasons; subsequent versions are GPLv3), the two operating systems where clang sees most use.
Ultimately, clang offers a way forward without having to adopt GPLv3 software, and besides that offers considerable benefit to people making development tools. Its big selling point has never really been speed; that it can generally keep up is enough.
EDIT: You could certainly also make the claim that Clang's far faster compilation is a technical feature, especially for C++ programmers. There are actually people who use clang for development, for the fast compilation and static analysis, then build for production with a newish GCC.
To address your second paragraphs, I am responding to a comment (yours) justifying why clang should spend time on their website making comparisons against gcc 4.2, a stance you defend by stating that that is the version that people are using instead of clang. Now, in your response to my defense against that point, you are bringing up legitimate technical benefits of clang against all versions of gcc...
...but I would never, nor have I so far in this thread, complained that those benefits didn't exist; I especially haven't claimed that those version-independent architecture benefits shouldn't be mentioned on their website. My complaint, remember, is that there are specific nebulous benefits (error output) being touted against gcc 4.2 as the "most notable" (according to the SO answer being discussed) technical be benefit of this project.
That specific benefit only exists because of a licensing decision, as gcc after-4.2 does not have error output this bad (not do I believe it did in 4.3 trunk at the time that website was published). The honest reason, if "error output" is important, as to why clang is better than gcc for FreeBSD is thereby "licensing", as if licensing weren't the real reason that benefit evaporates: it is no better than just pointing out that gcc 4.2 is unmaintained.
However, and again, you are more than welcome to be happy or excited about any other real benefits, either to other parties or the ones in question, but your comments in this context are anticipating complaints I haven't made and in fact is aggressively arguing with me over something I don't even disagree with: it is as if you see anyone complaining about clang and presume "they must just be a hater" and knee-jerk your way through a muscle-memory argument over "why clang is better" (something I have no strong opinion about).
[1] http://www.phoronix.com/scan.php?page=article&item=llvm_33sv...
talks about the experience provided by the command line compiler, contrasting
-Clang output to GCC 4.2's output in several examples.
+Clang output to that of GCC 4.2 (current when the Clang project began)
+in several examples.
<!--It seems reasonable for FreeBSD to favour BSD licensing.
EDIT Ah, I see how: you're talking about clang's website, whereas I'm talking about the submitted link, which is about FreeBSD. Note: the same argument also applies to other companies avoiding the GPLv3, which would explain why clang's website uses gcc 4.2 in its comparison. Though people here mentioned the GPLv3, no one noted that 4.2 was when the gcc license switched to it (I checked the HN comments).
FWIW I've seen a GPL project eventually lose out to a BSD-style competitor, and the latter were surprisingly nasty about it, similar to what you're saying. This might be due to commercial interests vigorously supporting the BSD-style version for reasons of MONEY. But apart from nastiness, it makes sense that a more permissive license, being free to a wider audience, will be more popular. OTOH perhaps here, for a compiler, requiring people to give back (GPL) will work better? OTOH2, promising new tech always gets a certain ersatz caché - whether that promise is fulfilled or not.
gcc is still better at optimization, though. For now.
[edit: wow, people are really confused here. Guys, LLVM was designed from the start to have a clean separation between passes. You can compile some other language to the LLVM bytecode and then just use the code generator, for example. It even includes a JIT! In contrast, gcc is a huge monolith. The projects are written in different languages, too... C++ versus C.
tl;dr is that when you say that "the only difference is the license," you sound like someone saying "the only difference between Ruby and Java is the file extension." Pointy haired.]
gcc has been becoming more modular over previous releases, and is becoming more modular in the future. For example, there are plugins since 2010.
Your information is outdated, so it makes your opinion seem uninformed.
I work with some fairly recent version of both compilers-- gcc 4.7.2 and clang 3.2. I also know a developer on the LLVM team. clang is way ahead of gcc in many ways, and the gcc devs know it.
We still ship software built with gcc, rather than clang, because gcc is still better at optimization. (gcc also supports more obscure targets, though that's not our biggest concern).
We also make use of llvm's ability to dynamically recompile code on the fly in Cloudera Impala. More information here: http://blog.cloudera.com/blog/2013/02/inside-cloudera-impala...
This would not be possible with gcc no matter how much work we did (license issues-- Impala is Apache 2.0, gcc is GPLv3).
As a result, gcc is substantially harder to understand and work on than other compilers of similar scope.
As a result, new development effort, both personal and corporate, is going into clang.
As a result, even if clang is only approximately at parity with gcc now, people expect it to improve faster in future, and therefore to be a better choice now.
All of these contribute to what http://lists.freebsd.org/pipermail/freebsd-questions/2012-Ju... says are non-licence reasons to replace gcc:
1) GCC's continuously increasing propensity to generate "bad code",
2) The inability of GCC mamintainers to fix _long-standing_ bugs, some
have been identified for over a decade, and have not been fixed.
3) The continuously increasing trend of introducing 'non standard' features,
4) The growing need to 'write around' correct/valid code that GCC will not
compile.
5) The fact that the GCC code is 'unmaintainable' -- *NO*ONE* (other than
someone who has been working with GCC internals for "forever" --a decade
at an absolute minimum) has any chance of 'understanding' what it is
doing internally.GCC plugin needs to be GPL-compatible, and GCC includes a license check similar to Linux kernel module tainting. (Instead of tainting, you can't run plugin at all.) http://gcc.gnu.org/onlinedocs/gccint/Plugin-API.html
Case in point: their SMB stack.
To me this shows that Apple would just not have used (and contributed to) any free software if it was all GPL3. The world would be a worse place. In fact, the world has gotten considerably worse, Apple-wise, when we lost Samba in OSX.
The patent clauses in GPL3 make that license completely unsuitable for any company (with cautious lawyers) that owns significant patents. I can really kind if understand Apple here.
The only significant change that FSF did was adding an additional point regarding patent agreements. They describe that: If you have an expressed permission to practice a patent or covenant not to sue for patent infringement, such agreement is seen as identical as if you were holding the patent yourself.
If you are in a company that has significant amount of patents, and who would prefer keeping a patent rather than gaining benefit from free and open source software, then one need to keep an eye on any software one want to distribute that has apache, GPL or any other licenses with a patent clause in them.
If you are in a company that has significant amount of patent agreements, then one need to keep an eye on any software one want to distribute that got GPLv3 software in it. Apple do have a few such agreements.
What he has said is that he personally don't like DRM, but he thinks it outside the scope of the kernel and a software license (see https://groups.google.com/forum/#!topic/fa.linux.kernel/L5NR...)
So MBCook's statement is fairly accurate, to the best of my memory.
But I'm only here to clarify the very important point about who owns the hardware in question, not to call either license better.
The *BSDs prefer a non-GPL licensed alternative if they can get one.
Also, as noted in the comments on StackExchange, BSD licensing vs GPL may be reason enough to discontinue the use of gcc in FreeBSD systems.
Any new C compiler has to either just be a C -> optimised C compiler (in which case why not just write an LLVM pass) or duplicate all of the optimisations which exist in LLVM/gcc.
In other words, FreeBSD ships with a gcc binary, which means FreeBSD is distributing gcc, which means all clauses in the GPLv3 apply to them.
Any group/company/whatever wishing to ship FreeBSD that doesn't strip out the compiler will be affected similarly.
Sylvestre Ledru spent some time on this in particular in his talk at this past FOSDEM[1], taking the above as evidence that clang is now mature enough to support the Debian archive.
[1] https://archive.fosdem.org/2013/schedule/event/debian_clang/
Clang doesn't need to be a drop-in replacement and I think it shouldn't be, but let the buyers beware.
I think having multiple different interpretations of undefined behavior a good thing. Means new standards could likely define it. Also shows how much code manages to compile that probably shouldn't. I know i've been surprised with what ambiguous stuff gcc has allowed in my own code.
Any C or C++ developer doing cross platform development, even if only across UNIX platforms, will have lots of war stories to tell about using different compiler vendors across systems.
Given what happened in the financial markets as they were deregulated I am extremely suspicious of the notion that removing the constraints of Copy Left will actually be positive in the long run. I have no doubt that it will help companies like Apple but I don't see the benefit for the wider community of developers.
If someone wanted to be a dick about it they could release modified GPL code as one big diff and publish it on some obscure webpage only their customers have access to. Instead we see more and more companies and individuals becoming friendly open source citizens. Perhaps some because the GPL mandates it but I would like to think mainly because they feel it's right thing to do—copyleft or not.
Of course, people can use whatever license they want. I personally favor licenses that maximize the rights of my users. Hopefully, though, you can now see that the combination of positions you mentioned is a consistent one.
Your statement is a shining example of the fallacy fallacy though... just because one interpretation of what I said on a detail of it is incorrect, that in no way invalidates my statement nor the existence of vocal people like those I describe.
That seems pretty in step with the GPL.
I think that there is a powerful value in sharing, however. On a physical level, the old-fashioned term is "being a good neighbor". The GPL enforces sharing contractually. There's also a powerful value in being able to fix things that you use. And the GPL enables that as well, also contractually.
So I prefer the AGPL3 when possible, because I believe its values align with what I believe to be the best for society.
More likely, a libertarian in the contemprary American sense of the term, though the labor theory of property is at least Lockean in vintage.
I misread this at first. I think this makes the point more cogent:
the same people who get up in arms about government, and bitch and moan about "rights to the fruit of my labor", don't like the notion that someone can claim "the rights to the fruit of their" labor by putting a gnu license on something
#2 Hosting/cloudiness?
#3 Administration?
#4 Custom adaptation?
#5 Privileged early access to updates/content files?
All those different strategies has been used to "sell" GPL software. Even the last one has been used, even if their customers could repackage the update and redistribute it to non-paying customers.
Then there's the recent example of Openshot, a GPL licenced video editor where the author went to kickstarter to gain funding for improving it greatly, the goal was $20.000 and it reached $45,028.
I see a combination of these models as a future popular way of making money out of your open source efforts.
Dual-licensing effectively says, "We'll let you take away user freedoms, but only if you pay the original copyright holders." Which is akin to openly bribing communist party officials.
Kickstarter projects is USA specific, and it seldom works if you need a steady income of money.
As for steady income of money, true that this type of funding isn't of the steady pay-check variety but if you can continue to add value to your project then it could become a long term income.
Either way I'd say the vast majority of open source desktop software today is done without any compensation and during developers spare-time, things like kickstarter opens up possibilities for them to actually make money while doing what they would likely have done either way, and it can also give them the financial opportunity to work exclusively on the project for a period of time.
Quoting from the VideoLAN web site, > x264 is a free software library and application
That is a developer tool on my language.
The possibility of a dual licence gives the creator a compensation because he waives the rights the GPL gives him for you.
Also: Support contracts. A lot of poeple live in the support ecosystem and adapt GPL/BSD software for costumers.
Fixed:
If you use ANY GPL code in your product you have to provide the source.(There are of course exeptions eg LGPL)
Also it isn't simply derivative work that that can be forced to re-license under the GPLv3. If FreeBSD had elected to adopt a GPLv3 compiler and distribute the source(as they do with the compiler) then the FreeBSD kernel itself would become subject to it. In fact, it isn't just gcc which has this restriction. Any GPL v3 code isn't allowed in base.
Further reading:
http://www.freebsdfoundation.org/press/2007Aug-newsletter.sh...
The GCC 'runtime library exception' firewalls all 'target code' from the GPLv3, and even allows proprietary preprocessors, linkers and assemblers (but nothing that would involve modifying GCC to split what it does in to more granular stages)
You have to license any code that links with GPL code under the GPL. This does not prevent you from dual-licensing your own portion of the code base, or shipping non-GPL, non-linked code as part of the same product (Although in the case of things like DLL plugins it gets a bit hazy)
Actually, that's a common, but wrong interpretation. The whole work becomes GPL, but the code that links to GPL code doesn't have to be GPL.
What you shouldn't do is to hope that anyone will pay you.
The first person who pays can offer exactly the same thing for $0.
It's impossible to convince anyone that they should pay you even $1 if exactly the same thing is available for $0 from somewhere else.
The ability to charge for GPL software is purely theoretical. In practice, you can't.
Actually the majority of corporations are leechers, using it as "free beer", only paying back if they really have to, as many corporations don't use software without support contracts.
Or happen to have some FOSS followers taking business decisions.
Otherwise, I can tell you from my experience working on Fortune 500 consulting projects, very seldom is any money or contribution given back.
Radiohead's In Rainbows, the Humble Bundles and other pay-what-you-want sales disprove that statement. All had average purchase prices well above the minimum. (That doesn't mean such a model is very profitable compared to fixed prices, of course.)
Even in a purely self-interested point of view, there are reasons for paying (e.g. keeping development active).
Maybe so; can you point out those cases where the average payment for a pay-what-you-want sale was no higher than the absolute minimum?
hardly a model to follow for anyone that needs a steady source of income to pay things like mortgage, employees and such.
That's a very different claim from what I was contesting.
But in any case, it may work in when you have modest needs; Joey Hess just got his second year of development of Git-Annex funded[1]. Of course, not everyone is willing to work for $15k/year, even if it comes with few strings attached, particularly obviously talented and experienced developers like him.
That is the main point, in Germany you can earn around 5x that on an average consulting job.
Apple has made more money form free software than anyone else, and they can pressure FreeBSD to stay away from GPL3
Yes; Apple can pressure the FreeBSD project to stay away from GPLv3, through their evil Apple magic. In fact, they are presumably pressuring the whole world to stay away from GPLv3, as it has seen almost no adoption outside the FSF! Naughty, naughty Apple. If not for mean ol' Apple, the FreeBSD project would no doubt rush to embrace GPLv3, discarding their horrible old BSD license!