Chrome now uses clang for production builds on Linux
article.gmane.org
article.gmane.org
* Modern modular design (everything is libraries) * Faster compile times * Nicer error messages
The modular design in particular is a good reason that might not be obvious at first. It lets you do things like debuggers, code formatters and static analysers in a much more sane and robust way than GCC's "no plugins, everything must be separate and flaky" way.
[1] (similar talk) https://www.youtube.com/watch?v=mVbDzTM21BQ
the 3 giants are working together...
Even GCC developers (like I was ) don't really question it.
The only thing GCC buys you right now, at all, is slightly better performance (it varies depending on your benchmark) and support for a larger variety of odd embedded systems.
On the other hand, LLVM is very easy to modify, can be built as a library (as can clang), has a sane, well defined IR, etc.
Your reply certainly implied you thought GCC was fine along the same axises your parent said clang was better.
"But I hope that it is still allowed to say that GCC has made progress the past few years." You are talking to a guy who helped make some of this progress (for example, I helped build the tree-ssa project that brought a language independent middle IR and SSA optimizers to GCC). It's certainly made progress, but that progress had been fought about for the 5 years before that. At the same time, GCC lost good developers during these fights due to wanting to get stuff done and not deal with politics.
"Also, there's the license/freedom thingy, which might not interest you, but others do care about such things."
Actually, it interests me immensely. I helped with things like the libstdc++ exception, etc. Besides being a compiler guy, i'm an open source lawyer.
But in the end, I choose stuff based on technical merits first, freedom second. You are of course, welcome to do as you please.
No. I simply corrected a false statement regarding gcc. I did not compare it to clang at all. I have no illusions how gcc does compare to clang w.r.t. to code quality, modularity, etc. As I've said: it would be weird if it were otherwise. It's really not hard to beat gcc in that area.
> You are talking to a guy who helped make some of this progress
Thank you (no irony intended).
> Actually, it interests me immensely.
It may interest you, but as you say yourself:
> But in the end, I choose stuff based on technical merits first, freedom second
>You are of course, welcome to do as you please.
Will do, thanks.
Apologies for replying in-thread (I couldn't find contact in your profile). Would it be possible to ask you a few questions about a perhaps-novel compiler licensing question for an open source application we're developing (we're a commercial entity and can pay for your time)? If so you can reach me at the email in my profile.
But sometimes I wonder if the license doesn't play a role as well.
Of course, given the source, apply salt :-).
The last time I checked gcc still had better performance than CLang, but things might have changed since then.
2. LLVM is a lot easier to improve.
> With the switch to clang, binary size dropped about 8% while performance mostly stayed the same. Startup time improved a bit,
Also I can imagine it might be nice to use the same compiler on different OSes, and gcc is very much a 2nd class citizen on mac.
I think it's pretty acceptable, if you're writing C. As you can see, C++ support is only partially completed (no exceptions!). But you're right, Clang on Windows gets constantly improved.
The creation of good debugging information (MSVC's /Zi or even /ZI option) is also missing. For a first class citizen, support of the (undocumented) PDB format is a requirement in my opinion.
You can now build a fairly well-functioning chrome binary, from visual studio, with clang/llvm, without source code changes.
- Useful warnings, they look good, and are on by default.
- More than a compiler, lets you build your own tools (example: AddressSanitizer)
- Better performance (less time) with clang vs. gcc for both -O0 -g and -O2 (at the time the benchmark was done on 8 cores, 24GB)
In summary / tl;dr : they enjoy diagnostics, the clang code base, how it works, and the ability to write their own tools. It seems like it's more to do with preference/performance and less to do with licensing. I'm sure that now they're doing many more things with clang since three years has passed since the aforementioned talk.
Which either defaults to using clang or gcc.
Over time, using Clang effectively will require proprietary modules from Google, Apple, et all and the GCC project, long dead, will haunt us from the grave.
We'll tell stories to our children about how when we started learning to program, it was easy to get started because compilers were free, but now the only free compilers are toys, ill-suited for anything but the most basic education.
A special thanks to everyone who helped make this possible by attacking GCC and championing LLVM whenever possible. I hope it's very, very easy for you to write extra modules for your new proprietary compiler.
http://llvm.org/docs/DeveloperPolicy.html#license
To others: I presume what the parent comment is complaining about is that companies are legally allowed to modify the llvm source and distribute those binaries without source code.
This is not a bad thing, unless you're an open source zealot.
From the URL above:
> We intend to keep LLVM perpetually open source and to use a liberal open source license.
and
> We believe this fosters the widest adoption of LLVM because it allows commercial products to be derived from LLVM with few restrictions and without a requirement for making any derived works also open source (i.e. LLVM’s license is not a “copyleft” license like the GPL).
This is reasonable.
They have also traded away a way to encourage others to keep it open in return for wider adoption.
Interpret that as you will.
It's always fun to see people being more papist than the pope, though.
But Stallman put the GCC under the GPLv3.
So I don't think your comments re: papacy are terribly on-point.
s/encourage/force/
If you have to force people to do what you want, who cares. Leading is about getting people to go in a direction they may not want to go. Not pushing them off a cliff.
Many of us read the site always in this manner. While arguably this post (and a small but significant minority of others) are false positives, I find that most of the [flagkilled] posts are removed for good reason. The current system has flaws, but is not "complete nonsense".
Google literally upstreams everything we produce for llvm/clang.
We did the same for GCC, including things we could have kept to ourselves, like LIPO (https://gcc.gnu.org/wiki/LightweightIpo)
I have a lot of trouble coming up with a case where we wouldn't upstream something. Do you have any evidence for your concern, based on history, or is it all random hyperbole?
As both a GCC and LLVM developer, i can tell you that GCC lost entirely of its own accord.
PS it's somewhat ironic that Google contributed a lot to GCC, and you complain about it and assert they have poor motives because they decided to move to a different technical solution, yet from what i can tell looking at changelogs, you have never contributed to either GCC or LLVM. If you want the world to turn out the way you want it, you actually have to participate.
Personally, I see something as big as Chrome moving to LLVM as a late-stage indicator of the mass adoption of the platform. I'm young, as you've pointed out, and I've never worked for Google, but I'd bet that this decision wasn't made lightly, and it certainly wasn't made early in the lifetime of clang/LLVM.
The people truly at fault for the things I fear, should they come to pass at all, are not the late adopters like Google, but the innovators who decided to put their energy into LLVM, knowing full well how dangerous it could be.
I don't and didn't mean to imply that Google is going to stop contributing, or that Google never has.
I do think that Google's decisions to contribute upstream are based on business sense, as opposed to morality, and I think that should the day come that it makes business sense for Google to not contribute back, or to release a non-free fork, it'll do that. As others in this subthread have pointed out, Apple has already distributed non-free LLVM modules.
The concern I have is that this is possible with LLVM, and it was not possible with GCC. When Apple wrote a non-free Objective-C frontend for GCC, they liberated it because the Free Software Foundation successfully enforced the GPL. There is no legal mechanism to force corporations to contribute back to LLVM, so they do it of their own goodwill, if they do it at all.
I think this is dangerous because it can lead to a world where there are no good free compilers. The people who wrote LLVM, the people who championed it early on and contributed to it, they could have realized this too, and they did nothing to stop it. I truly hope they acted the way they did because I am egregiously wrong, and that nothing I'm afraid of will ever happen.
To put things in perspective, GCC had one fork in its history already. I think that if it was forked again, redesigned extensively to make it easier to get parse trees and add modules and so on, with the legal requirement that all such modules be free in any distributed compiler, the FSF would eventually, hopefully, accept that as the canonical GCC. It would have been harder to do that than to make LLVM, maybe it would have cost the world a few years of compilers research, but it would have been possible, and it would have made for a more secure outcome.
You are talking about things that people have been working towards for years. The people you see working on it now have been working on it since almost the beginning of LLVM.
Google is the company that put their energy into LLVM, knowing how dangerous it may turn out. But you don't have to take my word for it, check the commit logs.
Just because we didn't make a public pronouncement and try to get press for it doesn't mean it didn't happen.
"I do think that Google's decisions to contribute upstream are based on business sense, as opposed to morality, "
Then i'll just say you don't understand me or the folks that work for me.
"The concern I have is that this is possible with LLVM, and it was not possible with GCC."
It is in fact, possible with GCC, despite your claims. In fact, all you would have to do is change the C and C++ runtime libraries (which is entirely doable nowadays). That's it. The FSF knows you can interpose stuff legally as well.
" with the legal requirement that all such modules be free in any distributed compiler,"
It is probably not possible to make such a license and have it compatible with various GPL versions, etc.
"hopefully, accept that as the canonical GCC."
You also seriously misread what would have occurred in this situation. People tried what you are suggesting. RMS said no for many years, right up until the point it was probably too late.
Forking again was considered, by all the companies and people involved. But it wasn't worth it to any of them to have to have political fights with the FSF over software development every couple years, when they just want to get shit done.
I'm sorry, Google is a publicly traded company. Are you really saying that if there was a clear business reason to release proprietary LLVM modules, Google would damage their stockholders and continue to release them freely?
I don't think I understand you. I never made that claim. I do think that corporations exist to make money. I don't think this is unreasonable, and I think it's unreasonable to ask me to take such a leap of faith in the opposite direction of common sense when considering any corporation, even one as benevolent as Google.
>It is in fact, possible with GCC, despite your claims. In fact, all you would have to do is change the C and C++ runtime libraries (which is entirely doable nowadays). That's it. The FSF knows you can interpose stuff legally as well.
The GCC is released under the GPLv3. There are some libraries inserted into compiled code with a linking exception, but it isn't clear to me how you could release a fork of the GCC under a proprietary license.
If you make that claim, you're going to have to explain it in greater detail, because you're essentially claiming that the GPLv3 is totally toothless. My apologies if I've misunderstood you.
>Forking again was considered, by all the companies and people involved. But it wasn't worth it to any of them to have to have political fights with the FSF over software development every couple years, when they just want to get shit done.
I understand the desire to get shit done, but in some cases, you have to realize that there are dangers associated with charging ahead regardless of potential consequences. There's a reason why nuclear plants are rigorously regulated, even if a lack of regulation would probably cause more shit to be done.
And actually, none of this discussion about GCC or the FSF or whatever is even relevant. The authors of LLVM could have just released it under the GPL. They chose not to.
So if that decision costs the free world its compiler, they're who I'll blame. Not Google, unless Google was involved with that decision.
Except for the part where that it was literally said, yeah, ...
"He is not attacking Google and there is no reason to take it "personally" and entering to the "defensive mode" immediately."
Google was specifically called out as "sure to require you to use proprietary modules".I don't know how you can read it any other way.
I read that as "He is just giving examples for technology companies that use LLVM somehow" while you seem to read that as "OMG he's attacking Google specifically and intentionally and I must defend it immediately!", well, except that he didn't. There is no need to assume bad faith. Just relax a bit and keep up the good work you do on compilers.
We have never done so in the 10+ years of working on GCC or LLVM.
It's no more valid than me saying "Linus doesn't want to use GPLv3 because he wants to release consumer devices with the kernel and proprietary modules on it". IE it's complete unfounded bullshit with not a shred of intent or data to back it up, and goes completely contrary to the history of his work on the project.
In any case, we have no plans to release proprietary modules for clang/llvm.
That's not to say it destroys freedom, but its not ideal for a certain subset of software. The GPL is also not magical in this regard, since you have projects where things don't get up streamed.
Cost. If your advantage was perpetual and didn't increase your future support costs, then sure, you wouldn't contribute it back (ignoring belief / culture).
It isn't though. Someone will do something similar and even if they don't, each new version requires you to not upgrade or spend the time integrating your wonder code into the mainline again.
Long term cost of staying current is going to be an issue. Each change to your fork makes bringing in new features from the original harder.
Plus, in my mind, it is a nice self selected pre-screening filter for companies / individuals that would be good to work with.
There have been issues with GCC for over a decade that go unfixed and unchanged because it doesn't make the most business sense to contribute to it. In the category of interoperation in particular, the GCC project proved to be openly hostile to the notion; they left a wide gap in the market for Clang/LLVM to fill.
Does it matter if my competitor can take advantage of my bug fix in a compiler? I don't think copy left licenses are a good fit for every project, but there is certain infrastructure in the world where ideally everyone can benefit.
Which they achieved at the cost of correctness: https://code.google.com/p/android/issues/detail?id=58726#c10
And vendors do contribute performance patches back to AOSP. ARM's Linaro group has updated & NEON-enabled some libraries, Intel contributed SSE optimizations and x86 support in general, Nvidia contributed NEON optimizations, Imgtec for MIPS support, etc...
There's a cost to maintaining a downstream fork, and a slight competitive edge tends to not actually be significant enough to justify the engineering cost.
For instance Apple came out with A8X which I am sure required special clang codegen optimizations - where is that code? If that continues to sit behind Apple's closed walls then it's already proving OP's point.
But it's not an argument against clang, which remains a high quality free software compiler and one worth using. And citing the existence of said free software as evidence for the "end" of free compilers seems... weird.
Well, one could argue that clang and its license are inseparable and if the license enables the reality that more and more higher quality stuff remains proprietary and that the source-available clang version remains a step child or second class citizen then your "high quality free software compiler" point becomes at least partially invalid.
If on the other hand GCC's license means more companies contributed in the open and only a single first class product remained equally available to everyone then GCC ended up being a better product than clang.
Apple's variant is not free software, and that sucks. So it seems reasonable to argue that it would have been "better" had LLVM been copyleft. But that only extends as far as the facts on the ground, so arguing that we're seeing the "end of free compilers" seems silly to me.
We don't have enough facts yet to make the determination - clang is fairly young still - but for now we do have precedences and motives. Precedences you can look up and motives - well Apple dumped GCC because they wanted to be able to do things without legally being required to publish source. So it isn't entirely without reason to wonder if clang will face a second class future due to its license.
Sometimes people just want to share software without making a political statement that they may not agree with, or imposing a legal and/or social burden on others (or assuming one for themselves).
The adversarial, black-and-white, with-us-or-against-us accusations that some GPL advocates are known for are actually a big reason why many people don't like the GPL, and associate it with carrying a lot of baggage in addition to the actual legalese that defines the license.
Apple dumped GCC because they wanted control over their own destiny. They could not get GCC to go in the direction they wanted, and it was just a much larger amount of engineering effort to accomplish their goal.
Apple gave not a crap about publishing source to their GCC changes. In fact, they wished they could get more changes into GCC.
The licensing stuff is tangential. Yes, it's their stated reason, but it's a cover story. Do you really think lawyers run Apple?
Apple certainly isn't wishing they could "get more changes into" LLVM, they're deliberately witholding the extensive changes they have. The iOS 64 bit toolchain is an almost completely closed-source thing, despite being derived from a free software base. If Apple "gave not a crap" about releasing source, they had an obvious path to do so. That they haven't (and that they've invited PR messes like this argument) implies to me that they don't want to release it.
It would have been this way with GCC too. They had already written their own linker, etc. Apple didn't give a crap about releasing GCC patches, because it was not for an architecture they controlled.
Much like embedded gcc developers often do, for architectures they control, they are probably just delaying the release until it no longer provides what they perceive to be a competitive advantage.
They would have done this with GCC too (and did in the past!)
So it's a pure coincidence they stopped updating gcc in OSX right when it moved to GPLv3? And the reason they stopped updating bash, Emacs, etc., and dumped Samba, is also because those projects didn't move in the direction they wanted?
You talk about the rest as if it actually mattered to their developers. They stopped updating X11 and java too.
Have you considered that they stopped to look and just stopped updating the stuff that didn't matter to them anymore?
Past that, you literally ignored the main point: They stopped updating plenty of opensource stuff, you've just picked out the GPLv3 stuff and said "it's all because of this"
Not true. They switched to clang with OS X 10.7. That was 2011. At that time, their gcc fork, based on 4.2 and carefully avoiding any GPLv3 code, was already ancient and loaded with problems. Past that, you literally ignored the main point: why would they need a "cover story" in the first place?
llvm-gcc was introduced with Xcode 3.1, and clang/llvm in xcode 3.2. It targeted 10.5. This was well prior to 2011 , and seeded well before it was released. Again, you don't have to believe me, Chris's resume shows this:
http://nondot.org/sabre/Resume.html#Apple
"In this time period, my group expanded use of LLVM within Apple, supported new clients, built new features, and extended LLVM in many ways. We shipped llvm-gcc 4.2 in the Xcode 3.1 and major improvements for it in the Xcode 3.1.1 release."
That time period was in 2006-2008.
Apple made a decision that it was going to move if it could meet certain performance goals in the 2006/2007 time frame.
GPLv3 was not released until June of 2007.
In any case, this argument is pointless, you can just ask Chris why they moved.
So now that they are using LLVM hopefully they will grow out of their wishing and actually push out the sources for iOS clang toolchain some time soonish? Yeah I don't buy that.
(Given they care mainly about swift, Apple certainly doesn't care about keeping clang changes secret)
GCC isn't a better product now, what makes you think it will be in the future other than the license?
But worse than that, proprietary modules can be mixed-in to Clang and LLVM. So essential functionality can be hidden in proprietary modules. Imagine that Apple wants to do something nifty for Swift, but doesn't want Google to be able to use it in Go -- they'll release a proprietary module that can be linked into Clang.
All free code in LLVM can be forked and made proprietary, and no proprietary code can be reasonably expected to be liberated. So the balance of free to non-free code can only ever get worse.
I'm sure that the libre software world being based on a proprietary compile will be a great thing to add into the mix of pervasive surveillance and network penetration.
By your definition, any non-copyleft open source licensed software ceases to be open source 'in the broadest sense' once a proprietary fork exists. Which is just silly, some software is open source according to the open source definition or it is not.
Imagine that Apple wants to do something nifty for Swift, but doesn't want Google to be able to use it in Go -- they'll release a proprietary module that can be linked into Clang.
People who pick the Apache, MIT, or any non-copyleft open source license do this knowing that proprietary forks or extensions are possible. Not everyone's definition of 'freedom' is the same as the FSF.
Also, I would like to point out that the same thing happens in copyleft-land. Companies dual-license their code under a proprietary license and let contributors sign agreements, to shut out competitors and to get people to buy expensive proprietary licenses. Oracle thankfully uses the GPL for such strategies. In fact, they recently relicensed Berkeley DB and Berkeley DB XML under the AGPL(!).
I'm sure that the libre software world being based on a proprietary compile will be a great thing to add into the mix of pervasive surveillance and network penetration.
Just help me understand. FreeBSD takes the open source LLVM/clang, uses it to compile their open source software. And suddenly it becomes proprietary. How so?
This is also true of GCC. Lots of organisations have private forks and the GPL allows that. More generally, if somebody offers 'compiler as a service' over the internet then the GPL becomes irrelevant and they could add as much private code to GCC as they wanted. The GPL only forces you to contribute back under a very specific and narrow set of criteria. Criteria that the majority of software being written in 2014 doesn't meet. The GPL is largely irrelevant to most software shops these days - they freely incorporate piles of GPL licensed code into proprietary closed source products. They can do so because most new software is internal to organisations or delivered as an internet service. The GPL was designed for a different world.
Software freedom has been set back because of people clinging to the GPL as the final word in software freedom. Your kind of GPL centric propaganda results in young developers today thinking they are doing the world a favour by writing proprietary closed source web apps - because they are using FOSS GPL libraries, right? And targeting the 'open' web, right?
Do you AGPL licence all the code you write, including website backends? Does your employer? If not you should probably take a close look at yourself and consider that maybe you are part of the 'problem' you are decrying.
This would be true if people could not and did not write new free LLVM code/modules...
Proprietary forks and modules of GCC exist too. Shocking, I know.
I suppose in the corporate sense, these two things are indistinguishable, so I should specify that I meant non-free, in the free-as-in-freedom sense, but I don't think I was ambiguous.
I've been having this conversation in good faith, though my opinion is unpopular, and I'd invite you to do the same.
Both projects are politically motivated. GCC began explicitly as a project to provide a FOSS C compiler (few if any existed at the time). Clang/LLVM didn't start at Apple, but their development has been heavily sponsored by Apple, whose interest in the project stems from their interest in excising the GPL (and specifically the GPLv3) from their entire development stack. (Notice how the version of bash that ships with OS X is almost a decade old, and is also the last version that was released under GPLv2).
The fact that Clang/LLVM are released under a FOSS license today does not mean (A) that they always will be, or (B) all essential functionality will always be[0]. With GCC, being a FOSS compiler collection is their entire raison d'etre - it's right in the name![1]
Edit: Reworded sentence to remove ambiguous antecedent.
[0] (ie, it's conceivable in the future that nobody will want to use Clang/GCC on its own, but will essentially have to use it in conjunction with another piece of related software, and there's no guarantee that this software will be FOSS. With GCC this is not a relevant concern only because the FSF would never let that happen; it undermines the entire founding point of the project.
[1] GNU Compiler Collection
clang was designed to do that from the start, and for me this has lead to greatly improved C++ tools.
A friend of mine is a long-time kibitzer of C compilers, and his occasional remarks about the state of the world wholly harmonize with this - GCC was not good for interop, and the contributing process has a higher bar than others.
[1] http://www.imore.com/debug-48-melton-ganatra-episode-ii-unde...
Apple wanted to integrate the compiler more deeply into their IDE, Xcode. GCC didn't allow that without making Xcode GPL too - which was out of the question. Apple has no problems contributing changes back to GCC or clang -- but there is no way they will make XCode open source.
Clang allowed Apple to take their IDE to a whole new level. Since the move to clang, features like code completion, scope higlighting, refactoring tools and inline error display (with somewhat helpful autocorrect suggestions) have vastly improved.
Apple didn't want to get rid of GCC out of spite, butthe restrictions of the GPL were holding them back. If you are a supporter of copyleft licenses, you'll see this as a success (hindering proprietory software), but from Apple's perspective it is obvious why they chose to support a compiler with a more liberal license.
And a major problem with GCC related to the GPL is that it has historically resisted changes which would make it easier to integrate even into an open-source project, though it has eased up on this a bit lately (possibly due to competition from clang?) Still, there's a reason that code completion and other code-aware plugins for things like vim and emacs are increasingly clang-based.
Commercial software usually has the same problem. Those dang companies won't give me their source for free, and they demand a license fee to integrate their products into mine!
The issue with the GPL is less the GPL than the multitude of authors for any one project. There are many single-author GPL projects which happily accept money for a non-GPL version of the software.
That becomes much harder when you have 40 authors, some of whom are dead..
This is not accurate in any respect. It would be accurate if you said "early development" (original development was sponsored by UIUC).
Their interest in the project was not at all in excising the GPL. They didn't care. That was a political position they took once on a GCC mailing list. But lawyers do not run Apple. If they wanted to keep using GCC, they would have kept using GCC.
They wanted faster build times, a better infrastructure, and something they felt they could invest in and not have this amazing uncertainty about where it was going and what it's goals were. They also didn't want to have engineering stymied by the politics of GCC (it is less political now, it was very political then).
Or it could be a frontend for a new proprietary language.
Or a backend for a whole new architecture.
The versions of Clang and LLVM that you have today will ALWAYS be available under the license they're currently under.
You're fear-mongering that the current contributors of Clang and LLVM may, in the future, make new releases under licenses you don't like.
But if people like Clang and LLVM, they can fork the current code, and keep adding features to it under a compatible FOSS license.
This is a bold claim! Are you providing the hosting?
I view the flamewarz between BSDish and GPLvX licenses as similar in spirit to the arguments between laissez faire capitalism and northern European social capitalism.
Also, I don't want to force my ideology (I find FLOSS preferable) on other people, while still giving my software away. However, technical reasons such as the above were 50% of my license choice.
Given the vagueness of the GPL, I can fully understand that many companies do not want to deal with that, even if they want to contribute to FLOSS in some way.
I disagree - the definition of software being free to modify and redistribute doesn't change based on the intent of the modifier.
There are more restrictions on your freedom to do these things under GPLvX than under Apache/etc.
A software author chooses which license based on the desire to encourage societal interests or individual interests, but the underlying meaning of 'free' remains constant.
All of this is not to say that I think it's entirely clear that copyleft licenses do lead to more freedom overall. My initial statement was precisely that it's not particularly clear. My personal expectation (which I'd argue for if we want to go down that path but hold weakly in that I consider other views reasonable) is that it varies from case to case.
EDIT: Essentially, saying you aren't free because you're not free to kill me without repercussion is absurd. GPL advocates view freedom the same way: You can't do something to hurt me, but that doesn't make you less free.
It seems your analogy is a wee bit overwrought.
For the record, I believe that the BSD and MIT license allow the distributor to withhold source from me, which does "hurt" me from my point-of-view.
As an example, How many chemistry and biology lab machines have you seen running windows 95 or dos because the company won't release updates for old software and want you to buy a new machine?) I've seen many, and it's very difficult and expensive to keep them running at times because they don't work under emulation for various reasons.
No, it pretty much does: http://www.merriam-webster.com/dictionary/freedom
It's true that too much freedom can produce awful results but let's not redefine the word?
To reference Erich Fromm, its not about "freedom to", but "freedom from". If you modify or distribute a work based on a copyleft work, you have "freedom from" being sued for patents, DRM, or proprietary copyright restrictions. If the work was based on a permissive licensed work, no such freedoms are given. You only have freedom to distribute the original work or modifications of it.
Personally, I'm happy for others to use most of my code without contributing back. Does that therefore mean that you and I have different definitions of the word "freedom"?
If so, then why isn't that in the dictionary? Do we need separate dictionaries?
Freedom to, and freedom from, both include the word freedom. They share philosophical ideas, most which originate from the ancient Rome. The question we are having is how to solve the paradoxes which said philosophy created.
I thus personally prefer to use the word liberty rather than freedom. Liberty is commonly understood to have a philosophical connotation, while freedom is more associated as mechanical concept. A slave can reach freedom by running away, but to gain liberty, they got to be given rights.
(Not to imply that BSD isn't granting some liberties. It is. The above is about the word freedom.)
This is exactly the conflict I was referring too, thank you.
The GPL does nothing to assure that code will be available. It does assure that if code is available, then it will also usable under Free terms.
I do believe you're wrong. If I am using software licensed under the GPL, then the code _must_ be made available. That's the crux of the GPL.
If you are distributing software under permission of a GPL license (e.g., you aren't the copyright holder) you are required to also make the source code of what you are distributing (which may not include all of the original on which it is based) available.
If you are using software that you received that was licensed under the GPL, the source code may or may not be available (it may have been required to be at the moment the software was distributed, but whether it will be later or not is less clear), and the source of the upstream may or may not be available even if the source of what you received is.
GPL doesn't keep the source code that it is attached to available, it assures that the software or legal derivatives will not be legally distributed except under terms that make the source code available. This may encourage the source code to remain available (if there are factors encouraging the distribution of the software), or it may not.
Otherwise, you should be able to request the source and the distributor would be required to give it to you under the terms of the GPL?
That literally makes no sense.
I was responding to the assertion that the GPL isn't about freedome because it imposes limitations. Living in a free society also has limitations, as an example I used killing another, but we still consider the society free, so the argument doesn't hold water. Limitations =/= Unfree
Also, I never asserted that you couldn't help someone. You're free to work on your own code or other code licensed under a license you find to be fair by your own terms.
> I'm glad I'm not a part of that cult.
I'm not sure what you're referring to, as I believe what I do because I chose to and have come to this position through much debate and reading; I'm not part of any group whose dogma I'm backing. I'm perfectly free to change my opinion on the matter, without repercussion.
Please stop using hyperbola, ad hominems, and baseless (nay useless) analogies and please write a coherent rebuttal if you choose to debate this subject.
People make the example about killing because there are the conflicting freedoms of two people involved: the killer and the victim. And people make that example as if the GPLs restrictions always involved such a conflict. This is not true. The GPLs limit my freedom to do things that are not an attack on others' freedoms. For example, the freedom to combine and redistribute GPLv2 and GPLv3 licensed code. Or the freedom to share a binary with someone who needs it, without forcefully bloating the distribution with a copy of the entire source code (which that someone likely didn't ask for, doesn't need, and doesn't want to have). The alternative of providing a written offer for the source code (valid for years) can be unacceptable for me because I cannot promise to meet such a requirement -- it makes helping people out potentially very expensive and painful. Therefore my options are to 1) violate the license and lose my freedoms as per the GPLv2 death clause, or 2) not share with the person in need.
I don't see how I would be violating anyone's freedom in case 1 -- but I lose mine (if I had freedom to begin with, I think that is questionable). In case 2, the GPL is definitely not helping towards ensuring freedom for either me or the person who needed my help. No, the license is just restricting both of us.
> Please stop using hyperbola, ad hominems, and baseless (nay useless) analogies and please write a coherent rebuttal if you choose to debate this subject.
It's useless to make a coherent rebuttal because GPL fanatics will just make some incoherent arguments about users versus developers' freedoms. Oh yeah, my freedom to help a friend is a developer freedom, and therefore does not matter. Me wanting to help a friend is like wanting to kill somebody. The society is better off without letting me do such evil.
If you think this is freedom, you have such a twisted and distorted understanding of the word that you're as good as a cultist.
What about the developer vs the user? That's the very conflict we're discussing here.
> The GPLs limit my freedom to do things that are not an attack on others' freedoms.
That depends on what you believe my freedoms are. I believe that I should have the source of anything I run; in such a case you withholding source from me is an attack on my freedom.
> For example, the freedom to combine and redistribute GPLv2 and GPLv3 licensed code. Or the freedom to share a binary with someone who needs it, without forcefully bloating the distribution with a copy of the entire source code (which that someone likely didn't ask for, doesn't need, and doesn't want to have). The alternative of providing a written offer for the source code (valid for years) can be unacceptable for me because I cannot promise to meet such a requirement -- it makes helping people out potentially very expensive and painful. Therefore my options are to 1) violate the license and lose my freedoms as per the GPLv2 death clause, or 2) not share with the person in need.
Two points:
1) Noöne is forcing you to use the GPL for your own work. While I would find it preferable, I would never force you to; I would simply choose not to use your software if you weren't making the source available (which you need not to under certain licenses).
2) I do not view "bloating the distribution with a copy of the entire source code" as a bad thing, and certainly not an excuse to not use the GPL.
> It's useless to make a coherent rebuttal because GPL fanatics
Thank you for the ad hominem
> incoherent arguments about users versus developers' freedoms.
You've yet to establish that the argument is incoherent, probably because, based on your first few sentences, you somehow don't believe it exists.
> Oh yeah, my freedom to help a friend is a developer freedom, and therefore does not matter.
You're not helping them if you're not providing the source in my opinion. You're simply band-aiding a problem at best and forcing complacency against usage of their own device at worst.
> Me wanting to help a friend is like wanting to kill somebody.
Again, I've literally never said this, nor implied it.
> The society is better off without letting me do such evil.
No, society is better off with people like you who have do believe in sharing your source, but are put off by some of the issues with the GPL. (Yes, I did just say the GPL isn't perfect.)
Society is not better off when someone takes previously free code, makes it unfree, and then proceeds to use it to lock users into their system.
> If you think this is freedom, you have such a twisted and distorted understanding of the word that you're as good as a cultist.
Thank you again for the ad hominem and hyperbole that really don't make much sense.
No, that's the false dicothomy GPL proponents keep bringing up. The freedom to modify code and the freedom to distribute the software (modified or not), is something you claim to be trying to be protecting for the users' sake, but as soon as I try to exercise these freedoms, you call me a developer and a distributor. If one can't exercise these freedoms without being labelled as such, these aren't user freedoms at all. But for me, as a user, the freedom to share (modified or not) software with other users is a very important way to help others out, and you people keep telling me there's a conflict in that.
> I believe that I should have the source of anything I run; in such a case you withholding source from me is an attack on my freedom.
Strawman argument. I'm discussing the scenario where I help people out by giving them software they need, and ask for. I'm not withholding anything, but if they're not requesting the source code, I'm not going to make life inconvenient for both of us by forcing it on them anyway. And just because I can help someone out at time t doesn't mean I can promise to give them the source code years after. It just doesn't work that way. Not making such a promise, however, is very different from "withholding source", which is the straw man you're making.
> Two points
1) Yes, I can choose to use whatever license I like for my own software. That has nothing to do with this discussion. Dismissed.
2) Then you do not understand what problems people have in the real world. If their system is broken and I'm giving them a file to fix that, I'd be very much of a douchebag to force them to download a potentially large archive full of source they don't need. Then tell them to download the tools to extract it (on their system that desperately needs help). Then tell them to remove all that crap so they can get just that one file they needed.
Likewise it would be very sad if I had to tell them that no, I cannot help you now by giving this file because I would need to find and download the source for it (the binary might've been compiled years ago).
Why do you have to oblige me with crap that doesn't help me nor the person I'm helping? And you are calling that freedom? No, it's not. And this "freedom" is the very reason I really don't help people much these days, or if I do, I do it either illegally or with truly free software, not this fake kind of free that tells me to bugger off should I dare share.
> You're not helping them if you're not providing the source in my opinion. You're simply band-aiding a problem at best and forcing complacency against usage of their own device at worst.
Your opinions don't fix people's software problems. Sometimes, files might. But there we go. Someone needs help, I help him, and the GPL fanatics say, oh look, clarry just almost slaved and murdered somebody because he didn't suffocate that poor fellow with a truckload of source code. So evil. The person who was helped thanks me and I might give him a tip as to how to avoid the problem in the future. Sure sure, you think I'm not helping him. He should just move to the first world and get a broadband so he can afford to download, who knows, maybe dozens or even hundreds of megabytes of source he doesn't need? And of course I'm responsible for finding and distributing all that, with my not-so-fast line. You think I'm not helping, I think you're insane. What ad hominem?
Since permissive licenses enable downstream users to recast the project into a proprietary state, denying those freedoms, then they are less free, in the free software sense.
Permissive licenses are developer friendly. They let you do whatever you want, including restricting users of your software. Copyleft is user and ecosystem friendly, by making it so any use of the code must stay available.
I can combine GPLv2 (eg. linux kernel) and BSD licensed code, and distribute it.
I can combine GPLv3 and BSD licensed code, and distribute it.
I cannot combine GPLv2 and GPLv3 licensed code, and distribute it.
As an end user, I like BSD licensed code more.
Personally I'm happy for people to use and modify the code I've given away, even if they don't choose to give back their changes.
It's two sides of the same issue: either way, the code is not available to you.
The Clang/LLVM license is both a free license as defined by the FSF and an open source license as defined by the OSI[1].
[1] https://en.wikipedia.org/wiki/University_of_Illinois/NCSA_Op...
People who use Copyleft licenses want the users of the software to have freedom. People who use permissive licenses want the developers of the software to have freedom.
GPL: "heres <product>, do whatever you want with it as long as you make all your changes public, oh and theres a ton of rules you need to conform to if you want to distribute <product> with <other_product>"
I don't see how a license with MORE restrictions can be seen as free-er.
And if you still want to exercise these freedoms, you're like, you want to kill people ... that's crazy!
Life goes on, and I continue not to share a large body of GPLv2 licensed code with anybody because it would be illegal for me to do so. I keep telling them it's because the license is not free, but it just doesn't seem to work.
I can add one word to the MIT license, and it becomes the least compatible open source license in existence. One word.
"Only the above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software."
You can't parse out the effect of permissions by counting words, paragraphs or lines.