Richard Stallman - Re: clang vs free software | Hacker News Reader

Richard Stallman - Re: clang vs free software

gcc.gnu.org

188 pointsnickmain328 comments

When I finally realized that the FSF is really about being a social movement and that creating useful software is a non-primary goal (or maybe even a non-goal), my level of annoyance with RMS greatly decreased. Of course, along with that, my level of give-a-shit about the FSF and the GNU project decreased proportionally.

Stallman wants you to use Free software because it's free-as-in-ideology, not because it necessarily works well or does what you want.

You've got it exactly right, but I don't see why that would turn you off of the movement, or at least keep it in mind as you develop and use software.

It's also a social movement that cares about what is the epitome of a first-world-problem.

Not necessarily.

If a 3rd world farmer is hamstrung by licenses on any tools they have (and seeds they grow), that could prevent them from making those tools better, or crossbreeding those seeds. Same with educational software and material.

Just because the focus is mainly on software, which is admittedly a 1st world problem, doesn't mean the ideals can't apply to the 3rd world as well.

Third-world farmers won't be hamstrung by licenses because the third world does not care about licenses.

Only until a first-world company has a third world militia torch his fields for non-compliance.

Exactly. You can extend it to pharma drugs as well, which potentially could save millions of lives. I respect rms' work philosophically, and he needs to take a hard line because his detractors are so entrenched in the power structures of the world.

The 3rd world uses software too, you know...

Not at all when you realize that the developed and a large part of the developing world is absolutely dominated by computing and software. We're heading towards a completely digital society of ubiquitous computing in every conceivable part of our lives, and there is no denying this.

Whoever controls our software, controls our world. Free software isn't a first world problem, it's a gigantic and urgent issue. It's only a shame that so many people don't realize this.

Open source works for a lot of cases (I wholly think BSD licensing is just fine for Clang/LLVM and disagree with RMS on this one), but it's just a pragmatic element. Merely a part of free software. Something being open source doesn't imply any particular redistribution rights and ethical guidelines by itself.

I would argue instead that it is a movement that is making a strong ethical claim.

Look, I don't carry water for FSF or Stallman, but it's easy to make that statement in the context in the world they helped create. You can't imagine how much OS licensing used to cost, which would definitely be an impediment to non first-world populations (from an infrastructure, education, and economic point of view to the extent they can be separated)

edit: to expound, the world they helped create is one where there is a durable, vibrant, and mainstream OSS culture where anyone with a halfway decent internet connection can download the source code & compilation tools for a state of the art OS. Radicals become irrelevant when they win.

It's not obvious at all that the GPL had anything to do with causing OS licensing fees to collapse. There are numerous high quality open source operating systems that are not based on the GPL, and the general reduction in price of commercial OSs is a function if competition between corporations.

I think the street children in Bangalore would disagree.[1]

People set up computer centers to help the poorest of the poor. Its a place where they can learn and express themselves.

Try set up such place and then pay for the OS, the text editor, the programming language, the painting program, the video editing, and so on. Compare that to finding some old used hardware being unused, and simply start helping the community immediately.

[1] If you want to hear more, I suggest one of the many talks from Eben Moglen. For a transcript of one, see https://en.wikisource.org/wiki/09NTC_plenary:_Eben_Moglen but its a bit short on details.

FSF is deontological and the "open source" movement, consequentialist. My personal ethics lean former, but I just can't quit my unethical Macintosh.

> Stallman wants you to use Free software because it's free-as-in-ideology, not because it necessarily works well or does what you want.

Though, the point is, you can make free software work the way you want or work better. You're _allowed_ to. That isn't necessarily the case with other software; that is the point of free software.

If this were true than clang would be considered free software by RMS...

There is more to RMS's version of 'freedom' than just being able to modify the code, the AGPL is a great example of this.

Clang IS free software, and RMS agrees. The difference is that GCC discourages proprietary extensions and subsequent lockdown.

> I would guess they describe their work as "open source" and do not talk about freedom.

Actually he doesn't....he considers Clang/LLVM to be open source and not free, Clang/LLVM does not restrict users from developing their own extensions and licensing them as they see fit which ironically makes the software not free (according to the RMS ideological software freedom purity test).

Nope. The NCSA license is considered a free software license and is GPL compatible according to the FSF. http://www.gnu.org/licenses/license-list.html

That's fucking great, my uncle bob thinks it is too, but we're talking about RMS not the FSF.

Do you even know who Richard Stallman is?

Yes, I just imagined that despite his polemic nature there were still other people who could put up with dealing with him who also were part of the FSF and therefore the FSF could hold positions divergent from those of RMS.

If the FSF consists solely of the opinions of RMS then I retract the previous statement and would say that the page mentioned expresses an opinion inconsistent with what is expressed in the email.

Generally speaking, the FSF and RMS agree. Nothing in the thread is inconsistent with this. RMS observes that the NCSA isn't copyleft, which is true, but that's a different dimension than free versus non-free.

But not different than free vs. open source.

"The values of free software are fundamentally different from the values of open source, which make "better code" the ultimate goal."

Clang wants to make a great compiler, they chose the NCSA license to facilitate that, according to the article makes it open source software and not 'free software' rather than 'unfree software'

Values and the question of whether a given license meets RMS's technical requirements for being free software are also two different metrics. He even explains that in this email. OSS puts an emphasis on the practical benefit of open source, whereas free software emphasizes the principle. And RMS never calls Clang nonfree in this email, he talks about nonfree derivatives of Clang.

So clang according to RMS is free as in freedom software that harms the free software movement because their unconcerned about freedom, rather than open source software that harms the free software movement because they are unconcerned about freedom.

I get you now, makes perfect sense.

Open source and Free software are essentially equivalent when it comes to licensing. The difference is in their motivation.

So when RMS says that, he's saying Clang/LLVM opened up the source code in order help their software perform better and see wider usage. Whereas RMS's goal for GCC is to ensure freedom for its users. Technical superiority is great, but it is not the goal, and may be sacrificed if necessary to achieve that goal.

He's not saying Clang isn't free software, he's saying their ultimate goal is not freedom, as contrasted with the FSF.

There's a couple claims here:

1) Free means freedom in the copyleft sense.

2) Free means freedom in the open source sense.

3) Free means free as in beer.

In the article RMS appears to be using definition 1, elsewhere on the FSF site the FSF uses 2.

"In the free software movement, we campaign for the freedom of the users of computing. The values of free software are fundamentally different from the values of open source, which make "better code" the ultimate goal."

It's very clear that "free software" in the article is definition 1, since MIT/BSD falls clearly in category 2, LLVM/Clang is NOT free software according to the definitions used in the article, and therefore the position RMS is advocating in the article is that LLVM/Clang is not free software, but rather open source software.

Yes to everyone else in the world, including the FSF, Clang/LLVM is free software but according to RMS it is not.

You're confounding issues here. RMS is in the position of a critic of the US government, rightly claiming that, while your country is "free", it installs and supports dictatorships all over the world. It is possible to be unfree, and not support other dictatorships, like Cuba.

It is possible to be both unfree, and support dictatorships, like the USSR. RMS's goal with GCC, is to be like the mythical free country that also supports freedom and discourages dictatorships elsewhere in the world.

In other words, your software can be free, and yet support and aid those who would take your freedom away. This is the claim RMS is making of Clang.

Except the the claim he is making is that free software is fundamentally different than open source.

"The values of free software are fundamentally different from the values of open source, which make "better code" the ultimate goal."

Perhaps you could provide quotes where RMS in the article says that clang is 'free software'. According to RMS in the article clang is a major set back for free software. (because it's better than their piece of crap)

https://www.gnu.org/philosophy/free-sw.html

http://www.gnu.org/licenses/license-list.html

clang is "free software" according to his own definition. It is entirely possible for a specific free software program to be a setback to the goals of the free software movement. His position is that copyleft licenses (very often, and certainly in this specific case) advance the goal of freedom more effectively than non-copyleft licenses. The differing values in this case basically amounts to whether one considers it worth using a copyleft license to ensure that the software being used remains free, or whether one considers it a drawback that a copyleft license may prevent it being used in proprietary software.

Interesting! The last time i looked, almost 100% of all compiled software of the linux-franchise was gcc-compiled, even a large portion of iOS and android software is gcc-compiled, and it doesn't stop there!

Furthermore which compiler-suite served as so long so good in the "dark" pre-LLVM ages?

Biting the hand, which feeds you comes to mind...

Clang/LLVM does not restrict users from developing their own extensions and licensing them as they see fit which ironically makes the software not free (according to the RMS ideological software freedom purity test).

This restricts users freedom, that is his point.

GPL is not about the rights of the programmer, it is about the rights of the end user.

The end users of gcc and clang are programmers.

You are correct in that the license is free, but it isn't a copyleft license.

This is a purely political decision: RMS wants gcc not only to be free software but he also wants it to be unusable to create non-free derivatives thus making it an active tool in furthering free software. clang undermines this because you can create non-free software based on it thus making it a tool that can easily be used to restrict freedom.

> clang undermines this because you can create non-free software based on it thus making it a tool that can easily be used to restrict freedom.

It seems that implicit in this claim is that if non-free software exists, its mere existence restricts freedom. Would that be a fair statement of anybody's position in this debate, or have I gone off the rails?

When non-free software is distributed, it is done so under the threat that the recipient will be thrown in jail if they share or modify the software.

Will the threat itself restrict freedom? Yes. Can threats cause harm? yes. However, so long its not distributed, no one is threatened.

So, on your question, no, its mere existence will not restricts freedom. The restriction happens once it has been distributed.

Exactly, if you read the whole thing it sounds like George Bush

> They have been supported by Apple, the company which hates our freedom so much that its app store for the ithings _requires_ all apps to be nonfree.

> The only code that helps us and not our adversaries is copylefted code. Free software released under a pushover license is available for us to use, but available to our adversaries just as well.

> If that enables GCC to "win", the victory would be hollow, because it would not be a victory for what really matters: users' freedom.

> The existence of LLVM is a terrible setback for our community precisely because it is not copylefted and can be used as the basis for nonfree compilers

Let me just say that your comment sound as Hitler, and we can be done with Association fallacies altogether.

https://en.wikipedia.org/wiki/Reductio_ad_Hitlerum

https://en.wikipedia.org/wiki/Association_fallacy

I must thank you, I'm kind of flattered you think I'm that charismatic.

Sorry about the charismatic way I presented my views, perhaps I should have mentioned my penchant for eating the raw uncooked flesh of freshly slain animals to make it more clear as to whether I was intending to advocate views similar to Hitler.

You may want to look into these links: http://en.wikipedia.org/wiki/Modes_of_persuasion

Im sorry, my subtle way of apparently was too subtle. I was not comparing you to Hitler, but rather made an association fallacy in order to create an irrelevant association.

If there was any persuasion in it, it was to not use irrelevant association since it do not add anything beyond a appeal to emotion, spun around a fallacy. Hitler, like George Bush, creates a guilt by association while the association is irrelevant tied to the subject matter.

The result thus becomes a polite discussion around the more creative ways of eating meat.

Interesting that allowing you to do whatever you want with a piece of software (e.g. selling non-free derivatives) is considered restricting freedom.

Allowing you to do whatever you want is not the same as allowing everyone to do whatever they want. You can't understand free software from an egocentric view of the world. A non-free derivative will ultimately restrict someone's freedom, hence, considering it restricting freedom is perfectly applicable.

We could debate forever on the semantics of which is more free, but I don't think having the freedom to restrict the freedoms of others is going to encourage freedom.

It's not freedom in any sense of the word. The FSF is at best a fiefdom, but in all reality a dictatorship. Stallmans utopian future is more 1984 than any of the actors he accuses. This whole thing is bullshit.

That's a common misconception amongst software developers, but in fact its not your freedom that's being defended, its the users of software. So let's rephrase that:

Interesting that preventing users from doing something with a bit of software (e.g. selling non-free derivatives) is considered restricting freedom.

Kind of self evident when stated from the users point of view really.

What 'users' of clang and gcc are not developers?

> What 'users' of clang and gcc are not developers?

I use gcc, and I work as a treesurgeon.

Do you not develop software with it?

I compile my C source code with it, or other people's. I don't sell the programs that I write, or get paid for writing them - for those reasons I don't consider myself to be a software developer, most of my peers think I am wasting my time.

I'd say more than 99.9% of them are 'using' GCC or clang, rather than 'developing' it, even if they are 'developers' using it to develop other software. So they're probably quite happy to have their rights as users privileged over their rights as developers in this particular case, particularly if it stops other developers from ruining things for them as users.

This case is about the GPL ruining things for these users - not stopping them from being ruined, which is why Clang is rising in popularity.

Your freedom ends where it conflicts with the freedoms of others. At that point, clearly something needs curtailing and the question is what/how. The GPL is one resolution.

My freedom to swing my fist stops at the tip of your nose; my freedom to modify legalese surrounding GPL software stops when it would deprive others of their "four essential freedoms" (in the words of the FSF).

0. The freedom to run the program, for any purpose.

1. The freedom to study how the program works, and change it so it does your computing as you wish. Access to the source code is a precondition for this.

2. The freedom to redistribute copies so you can help your neighbor.

3. The freedom to distribute copies of your modified versions to others. By doing this you can give the whole community a chance to benefit from your changes.

If you don't believe that these are important and should be respected, then you shouldn't be licensing things under the GPL. If you believe these are more important than the restriction imposed, then releasing under a permissive license is not itself "restricting freedom", but all it is doing (compared to the GPL) is enabling "restricting freedom". When the only thing a change does is make a bad thing possible, it's still better not to make that change.

I find it somewhat interesting we have no viral license that protects freedom 0 and 1 in derivative works but allows adding additional restrictions that conflict with 2 and 3 (or don't, which would make it GPL compatible...).

> When I finally realized that the FSF is really about being a social movement and that creating useful software is a non-primary goal (or maybe even a non-goal)

I think that, to a large extent, creating useful software, inasmuch as it is a pursuit of the FSF, isn't an independent goal so much as a mechanism for acheiving the goal of obstructing the development and spread of non-Free software.

free-as-in-ideology is brilliant, it so succinctly captures my feelings on RMS.

I think "free" is too much of a loaded term. "libre" seems to work a bit better.

I think you've completely missed the point of free software.

"Stallman wants you to use Free software because it's free-as-in-ideology, not because it necessarily works well or does what you want."

And I think, that's a better position to be in; I mean, freedom is more important than to have good softwares.

Execept it's not even that. It's a narrow definition of freedom. Free as in socialism vs free as in capitalism.

I believe, it is broader than you think:

we’re always telling children that they have to learn to share, to be considerate of each other’s needs, to help each other; then we go off into the real world where we assume that everyone is naturally selfish and competitive. But an anarchist would point out: in fact, what we say to our children is right. Pretty much every great worthwhile achievement in human history, every discovery or accomplishment that’s improved our lives, has been based on cooperation and mutual aid; even now, most of us spend more of our money on our friends and families than on ourselves; while likely as not there will always be competitive people in the world, there’s no reason why society has to be based on encouraging such behavior, let alone making people compete over the basic necessities of life. That only serves the interests of people in power, who want us to live in fear of one another. That’s why anarchists call for a society based not only on free association but mutual aid.

http://theanarchistlibrary.org/library/david-graeber-are-you...

I totally believe in cooperation and mutual aid. I believe it's critical for that to be based on trust and individual choice, or it is meaningless. This is why I don't like RMS's attempt to force it on us.

In that case, you ought, logically, to be against all forms of copyright and patents.

I am against patents, and I agree that by implication copyright is harmful too. I tend not to be an absolutist so am still considering my position on it, but I can't really defend copyright strongly.

Well then; Should copyright cease to exist, the GPL would have no power and would no longer have any meaning. But while copyright does exist, the GPL will continue to work against the imbalance of power copyright (and, lately, patents) create.

If I may make a parable: Don’t hate the rebels for being violent; hate the oppressive state against which they rebel.

The GPL doesn't work against the imbalance of power created by copyrights. It works to strengthen it by reducing the options for individual creators to make money from their efforts, and buttressing the power of established interests.

But - you make a good point - a good reason to be against copyright is because abolishing it would defeat the GPL.

RMS had a pretty testy interview with Z magazine a few years back. Was very emphatic that his vision of the future included businesses, and swatted down several attempts by the Z people, who wanted to abolish all businesses, to get him to reconsider.

Not bringing this up to argue that RMS is correct or reasonable (here or elsewhere), but I just thought it was interesting. RMS may be an unrealistic utopian, but his unrealistic utopia is some mutant form of liberalism - with property rights and commerce etc. - not communism or even big-s socialism.

Property rights for everyone except software developers.

If your freedom/rights takes the freedom/rights of others away, what may you argue about, if your freedom/rights is also taken away?

Because something might be inconvenient to you, it doesn't make it automatically wrong. There's a distinct line between free as in freedom and free as in arbitrariness. The former comes with responsibilities, the later without.

This is true but irrelevant because the freedom to distribute software without the source code does not take away anyone else's rights.

I beg to differ! As the NSA-debacle shows, it takes my right away to a) ensure there's no backdoor, b) the software i get does exactly what was promised and c) in a way and quality as advertised.

Furthermore take a look at the "USL v. BSDi" lawsuit, where BSD was sued by AT&T for infringing copyright-laws against their own(BSD) source-code, which was incorporated into USL(AT&T's) UNIX-variants!

"Freedom" comes with responsibility, if you want carefree "arbitrariness", then say so, but please don't mix them together, they are fundamentally different!

The NSA debacle is irrelevant to this and source code doesn't guarantee any of the desires you state there. I recommend studying software verification if you are unsure of this.

Furthermore they are not rights - they are desires.

You are free to negotiate terms with people from whom you obtain software, and you are free to refuse software without source code.

What the GPL seeks to do is force other people not to be free to choose their own terms.

Whether you like the effects of the GPL or not, it has nothing to do with freedom.

It's really not complicated at all. RMS is simply a social-democrat. He is the shining example of what social-democracy is really in practice. His position is not utopian at all, it's a very limited and specific, socially liberal, demand: it's unjust to have people be unable to do whatever they want with the things they own, not to mention having the things they own controlling them. Proprietary software does tend to limit and control its users, therefore we need to abolish proprietary software. It has nothing to do with hindering capitalism or anything like that.

I can see people in the USA having problems to properly frame his position due to the ideological burden of equating any kind of a demand for sharing and cooperation with communism or socialism, regardless if the demand actually has anything to do with left wing political motivations.

RMS's free software work isn't against capitalism any more than anti-slavery people's work is against capitalism.

RMS has steadfast refused to even entertain anti-business terms in software licenses as something fitting for a free software license, except to the extent that the "business" involves taking the free software in question and making it non-free.

Given that software is a tool, I would say it is more important that it work.

Is it more important even if it allows somebody to remotely disable the breaks on your car while you're doing 50mph? Or perhaps disabling your camera while you're being assaulted by a police officer? What about the predator who's monitoring your children's activities and location because they downloaded a game?

I picked some pretty harsh possibilities there that seem a little dystopian, but I wouldn't rule any of them out, or any of the million other horrific possibilities that increased coupling of technology to our lives, without (self-)regulation could enable.

If you really want software to 'just work', you should probably first ask, who is it working for?

Yes, software working for me is more important than the theoretical ability change or rewrite the software in some vague idea of source code freedom.

You are aware that all your attempted examples could simply be called 'not working' when evaluating the software.

It's a bit too late to find out if the software was working for you after the fact though. You can only evaluate the software in the first place if you have freedom 1, otherwise, you are going on hearsay, or this absurd notion that complete strangers are trustworthy by default.

I'm also not sure how I could say software is working for me if I must first agree to be dictated the terms of it's use, and agree that the vendor may dictate any new terms in the future, which I must agree to in advance.

>freedom is more important than to have good softwares

Yes, I agree, freedom to have the essentials for human survival is a lot more important than having instant access to the latest BF4 patch.

Care to provide a bit of qualification and relevance to your broad, context-free, ill-defined statement?

You can find the context by accessing the outer scope (parent comment(s)), you will also need to read the email.

I think I have a workable understanding of the context.

If the comment was meant to say that "free software is more important than good software", then it would be great to get a bit of elaboration and qualification for such a contentious statement.

That depends on the situation. There are certainly some pieces of software for which I feel that it is more important that it merely functions well at some task, and closed-source software is acceptable for that purpose. There are other situations where closed-source software makes me uncomfortable because I do not have certain guarantees about its security, reliability, or flexibility. I would say that the majority of situations are better served by open-source software, but not everybody feels that way.

I'm no expert, but this is not how I see RMS's point of view.

I think he does care how well stuff works and whether it does what we want--he just takes a very long-term view of that goal.

For example, let's say an ok V1.0 piece of open-source software is released under the BSD license. A startup takes the source, modifies it to create an awesome product, and releases that as a closed-source product.

Everyone loves it and adoption goes through the roof. The company gets hugely successful and is bought by Big Tech Corp Inc....who really just wants the talent. They EOL the great product.

Because it is closed source, the best that customers can do now is to reach back to original mediocre BSD'd code and try to replicate the development that went into the awesome product.

BUT--go back to the beginning. If the mediocre product had been GPL'd, then the startup would have been obligated to release their changes as source code. So even though it was EOL'd by Big Tech Corp, the customer base has the up-to-date source code, and can carry on development and support as a community.

Now, I'm not going to say that is a 100% accurate view of the world...the obvious counter-argument is that aggressive licenses like the GPL3 actually discourage business support of products. Thus a GPL3'd mediocre V1.0 would never have been picked up by the startup in the first place, and never would have been developed into an awesome product.

I won't say I know which argument is correct, but I will say I can at least see where RMS is coming from.

This happens a lot, especially in the SaaS sector. However your purchasing people or IT people (or yourself) need to consider this up front as due diligence. If you don't do it, you're a wally not a license martyr.

Portable, open formats are more important than the mechanisms.

What you call ideology I like to think of as taking the long view. The primary goal is to create software that will remain useful.

Time and time RMS has been proven right about the detrimental consequences of non-free software, but usually over the span of many, many years.

Non-free software has a habit of working well and doing what you want right until it doesn't and then royally screws you.

You can only be pragmatic about it (most of us are) if you are aware of the risks and consequences. Otherwise you're just being ignorant.

It is really very funny to read your and similar comments and to think why clang was created.

I don't get it. Why do you think clang was created, and what does that have to do wwith the GP?

To me, clang was created because gcc was working great for a lot of things, but wasn't working well for what some people wanted to do (and couldn't officially be made to do it without forking)

I have to agree.

I love free; what doesn't feel "free" to me is the GPL, since I can't use just about anything GPL in my job.

My job involves creating non-free software. Given the GPL's goals, it's not a surprise at all that I can't use it.

But it strikes me as ironic that RMS talks about "freedom" when really he's advocating restricting your freedom to use the software.

I understand it's in pursuance of a "greater goal" of Freedom to modify everything, but the problem is that, in the large, free software sucks, and I don't really want to be responsible for making it good.

Sure you can come up with a dozen really great free software packages (I'm using Firefox to post here, for one, and I make builds using gcc daily and gnu make). But I can come up with a thousand that suck -- and that includes the "best" packages in a number of different categories: Image editing, document editing, development environments (Eclipse has some nice bells and whistles, but that doesn't make it not suck), 3d editing... ALMOST everything with a GUI, browsers being a huge exception. [1]

Those are just the categories I've tried and tried again to make Free software work for me, because I am attracted to the ideal of working with Free software. But every time, the paid/proprietary solution has been so much better than the free solution that I've defected and paid for the proprietary version.

No, I'm not going to use free software to support an ideal. I'm going to pay for software that helps me get my work done faster and better. Because at the end of the day, I appreciate good tools, not ideals.

There may come a day when I try to make my own "free" software project, but if I do, it will be because I really want to make a world class tool in that category, and I feel that the free model is the best for that tool. But I will continue to choose my tools based on what they allow me to do, not their source code license, and the proprietary tools I do use offer me more advantages despite being closed source than their open source equivalents.

[1] Don't bother posting arguments about this or that free software package in these categories. Unless it's brand new and awesome, in which case I might like to try it out. Regardless, one example doesn't change my overall point, and I don't want the thread to devolve into "Gimp is great!" "No it sucks!" -- "Good enough" for one person is not always going to be good enough for another.

It's confusing if you think about it in terms of developer freedom, which the GPL isn't written for. It's about a user's freedom to run, study, modify, and distribute software however they want. It's this seed of freedom that prevents software from controlling the users. That's what the GPL protects.

So your objection to the GPL is essentially that it doesn't grant you the freedom to take away these user rights.

Isn't a user who modifies and distributes software otherwise known as a developer?

Exactly! Especially for programming tools like GCC or Clang, the end user is by definition a developer.

No, because they might be paying someone else to do the development.

So this is about protecting the rights of people rich enough to hire developers to work on bespoke projects that cannot be distributed as proprietary. I.e. Large corporations.

I am currently paying for some bespoke software development (split with two other individuals).

Is it under the GPL?

AGPL, as it happens.

While the above is the case, I'd just like to note that it misses the thrust of the subthread - my point was that it can demonstrably be affordable for other than "large corporations", which is the case regardless of the license under which I am releasing it.

I wasn't speaking in absolutes, so one counter anecdote hardly defeats the point. Bespoke development is clesrly out of reach of most end-users.

"I wasn't speaking in absolutes, so one counter anecdote hardly defeats the point."

You were talking out your ass, is what you were doing. An anecdote about THREE. INDIVIDUALS. doing X pretty solidly "defeats the point" that X is reserved to "large corporations" - we're not even a mid-sized corporation! None of the three of us currently paying for bespoke development is particularly wealthy (one is a part-time music teacher), if we'd gone overseas (or even out of state) we could lower development cost further, and the scope of our project is much larger than the minimum meaningful chunk of work.

"Bespoke development is cle[a]rly out of reach of most end-users."

Bespoke development is not out of reach of most end users, at least in terms of resources required. I would put forward that basically any user desiring a particular feature or small functionality change - outside of extreme examples - could financially manage it if 1) they cared enough and 2) they found sufficient friends interested in the same, and that for most users and simple tasks, "sufficient friends" is not a hugely high number. Organizationally, most users would presently have a hard time picking an appropriate developer and working with them, but that's a separate problem that numerous groups are working on solving.

With proprietary software, on the other hand, bespoke development is far further out of reach, because there is dramatically less competition - only the original authors can bid to modify a piece of proprietary software so no two groups are bidding on the same job.

I'm sorry you've chosen to stop being civil. It doesn't support your argument.

Bespoke development clearly is out of reach of most end users. There are billions of end users of computers now. You may exist in a rarefied stratum of the economy that gives you this freedom, but to claim that this is the case for most users is bizarre.

I am astonished that you think that choosing a good developer is the biggest challenge for end users who want custom software.

Your comment about proprietary software is invalidated by the examples of the web, Google Play, and the iOS app stores, which are brimming with highly specialized solutions which are developed because there is a business model to support the developers.

"I'm sorry you've chosen to stop being civil. It doesn't support your argument."

No, it doesn't support my argument. It also doesn't undermine it, and it served as a certain amount of stress relief in the face of an unconstructive and (in my view) absurd response, but it was nonetheless inappropriate and I apologize.

"Bespoke development clearly is out of reach of most end users. There are billions of end users of computers now. You may exist in a rarefied stratum of the economy that gives you this freedom, but to claim that this is the case for most users is bizarre."

Is your argument "it could not be sustainable, because there are not enough developers compared to users"? I don't see any other argument there, but as that one seems easily (if somewhat verbosely) addressed I want to be sure I'm speaking to your actual argument.

"I am astonished that you think that choosing a good developer is the biggest challenge for end users who want custom software."

Not just choosing a good developer, but collectively choosing a good developer, sufficiently defining the task, and communicating with the developer. I do think that is the biggest challenge for users who wish to customize an existing piece of software under a free license. It is not the biggest challenge for users who want to modify or reimplement a large piece of proprietary (or non-existent) software, but that is comparatively rare and it matters less the licenses of existing code. If you disagree, please be explicit about what challenges you think would dominate.

"Your comment about proprietary software is invalidated by the examples of the web, Google Play, and the iOS app stores, which are brimming with highly specialized solutions which are developed because there is a business model to support the developers."

That certainly invalidates any claim there can be no specialization in proprietary software, but I never made that claim. Freedom 1 is a right to modify the software I am running. That presumes there is an existing solution that's not quite what I want. If the license on that solution preserves my "freedom 1", paying someone to modify it is competitive, and therefore probably cheaper and probably better.

"I can't use just about anything GPL in my job."

"I make builds using gcc daily and gnu make"

Yes. So? Your point is?

I called it out as the only thing I do use.

And I may transition to Clang from gcc if a build problem I encountered with an older Clang version is fixed. That leaves gnu make.

And make sucks for many, many reasons, but that's not Gnu's fault. It's just that all the other building solutions suck more.

My point is that you do use a relatively large amount of GPL code (the gcc codebase is huge) and there are doubtless more GPL programs you can perfectly well use during development and simply choose not to. "I can't use just about anything GPL in my job" is a mischaracterization. What you can't do is incorporate GPL code in non-GPL code you are distributing (which quite probably does include most of the work you do for your job, although not necessarily testing frameworks, &c).

> But it strikes me as ironic that RMS talks about "freedom" when really he's advocating restricting your freedom to use the software.

It is ironic in a way, but it is only a valid criticism if you consider that you should have the freedom to restrict other peoples freedoms. This is generally considered to be immoral in modern society.

Not an other post about what "freedom" means :(.

Please read https://en.wikipedia.org/wiki/Negative_and_positive_rights and in particularly about the right to be left alone (negative rights).

Freedom of speech, private property, freedom from violent crime, freedom of worship, habeas corpus, a fair trial, freedom from slavery are just a few freedoms that can only be implemented by restricting others. You can't have freedom from slavery without restricting slave owners their right to enslave. Thus the term negative rights had to be made by philosophers and political scientists.

The proprietary model is to trade software for money, and then threaten your customers with lawsuit if they share or modify the program. GPL provide software under the freedom from those threats, with the use of negative rights (ie, the user of the program has a right to be left alone). If you can not make software without threatening your users, don't try to start by taking GPL software.

A number of companies have been sued for using GPL software in ways incompatible with the GPL, so I don't see how the distinction you're drawing here is meaningful.

I'm blocked from using GPL software the way I want; in that way I'm not free to use GPL software how I want. That is a "freedom," regardless of how you're trying to define the word. FSF is trying to grant one freedom by taking away another, period. Yes, it's my "freedom" to restrict how others copy my resulting software, but it's still a freedom. To claim otherwise is pedantic at best.

>If you can not make software without threatening your users, don't try to start by taking GPL software.

Umm...other than using it as it's designed and permitted (e.g., gcc), I don't. Any code libraries that are GPL (or even LGPL, except under specific circumstances) are dead to me. I'm annoyed when my time is wasted coming across one on a search. I would even bail on GCC for the superior Clang but I have one package (of many) that needs GCC to build in my current project for a client.

Almost all GPL code is likely to lose support compared to any BSD/MIT competition in the long term (except possibly for those packages used in server development, since they can be used commercially without being distributed, circumventing the intent of the GPL). Most non-server developers do their best to avoid linking to GPLed software because they're working on proprietary software.

RMS alludes to this in the article: "The existence of LLVM is a terrible setback for our community..." The superior network effects of BSD/MIT-licensed libraries means that those libraries will get more developers, who will fix more bugs and more features, which will then attract more developers, etc. (Not to mention the fact that LLVM is just more awesome than GCC).

As a developer I hate to have to rewrite code. Yet I'm forced to if the only code available is GPL; I can't change my business goals or those of my clients for the sake of a goal that's never going to be achieved. Asking me to is naive. The financial reality is that (most of the time) to make money writing software, you need to sell it (and therefore restrict the rights of those you sell it to).

The first 80% of a project is the most fun and satisfying; most open source projects rarely make it beyond that first 80% (if they make it that far) [1]. Companies that make money writing software will pay developers to complete the libraries they're using. As those BSD/MIT libraries get better, the GPLed competition will fall behind.

[1] Notable exceptions include the abovementioned server software category, where commercial/proprietary developers can use (and therefore will likely contribute to) GPLed code, and projects that have enough income to support full-time commercial development.

> My job involves creating non-free software.

> But it strikes me as ironic that RMS talks about "freedom" when really he's advocating restricting your freedom to use the software.

1. The GPL isn't restricting your freedom, your employer is. You are working under contract terms and policy selected by your employer. Your preferences aren't relevant.

2. The GPL isn't restricting your employer from using the software, just distributing proprietary add-ons or integrating parts of it in to their commercial products. They can still use it to compile and ship software, for free, giving nothing in return... that's still a pretty sweet deal when you go and look at the competition. Microsoft will charge you for the privilege of using their inferior compiler (full VS suite aside).

What kind of mindset says "Oh boy! B is giving me more stuff for free than A was, I'm going to go shit on A and make demands!"

The GPL is absolutely restricting what people do with software. To say otherwise is a lie.

No. Users of GPL software are under the right to be left alone if they want to modify or share the program. The developer who want to add restrictions on the program is the one who infringe on the users right.

This is true but irrelevant because nobody is talking about adding restrictions to existing GPL software.

There is nothing you can do with non-GPL software that you cannot do with GPL software that does not involve distributing code with more restrictions.

You can't distribute someone else's GPL code in a way that allows other people to redistribure it with more restrictions. That's a big deal if you want to mix GPL code with your BSD-licensed project, even if you don't personally touch any non-free software.

Hm, you can mix GPL code with your previously BSD-licensed project, and release the result under the GPL. However, I'll grant that that's strictly an exception there as I worded things. The only thing that could be done with the hypothetically-still-bsd combined work that couldn't be done with the perfectly allowed GPL combined work is to add more restrictions, though, so I think my general point still stands.

That said, not all restrictions are equally problematic - an obvious brokenness would be wanting to mix original-BSD-license code and GPL code; both licenses purportedly free (says even the FSF), but the 4 clause BSD code adds a restriction regarding advertising materials mentioning UC Berkeley.

>The only thing that could be done with the hypothetically-still-bsd combined work that couldn't be done with the perfectly allowed GPL combined work is to add more restrictions, though, so I think my general point still stands.

That's true, but if I'm a person whose only goal in life is to maximize free software, I may still be rationally motivated to license my project BSD instead of GPL. A BSD-licensed project can sometimes attract more users. Of course, that is because some of them will use it in their own non-free projects; but in many cases, their project would have been non-free anyway, and they would have just used someone else's code instead of mine, or written their own. If they use my project, it makes my project's ecosystem stronger, which is good for free software.

One can certainly make that case, at which point it largely amounts to a factual question and I don't have the data to answer it.

"If they use my project, it makes my project's ecosystem stronger, which is good for free software."

Maybe. If they run with your code and build a proprietary fork with a few features on you, and users migrate over, your project's ecosystem may be weaker despite the code being used by more people, and it would be bad for free software. It's hard to say.

No GPL do not restrict you with anything you do with software. The only thing is if you distribute binary, distribute code too. You may create addons system for paid apps or may be deploy business logic on cloud-saas and distribute thin client. you are not distributing business logic/binary so you can use it however you use.

>The GPL isn't restricting your freedom, your employer is.

I'm freelance. I write games and apps, and I do contract work. I can't use GPL software (except for GCC, which I already noted) in creating any of the products that I create because I need to make money.

Not everyone can make a Free product so popular that they can make money being paid to maintain it. I think there are probably fewer than twenty examples of such products that are actually monetarily successful for their creators, and I've read multiple stories of developers who had crazy-popular free products and who were unable to make ends meet.

Not sure how you expect "my employer" to make money giving products away for free either.

It's not "my employer" but the market realities that restrict my freedom with respect to GPL. I can't even publish an iOS app with GPL code; blame Apple all you want, but iOS and Android are gold mines of contract opportunities. You're telling me I should stand on some feel-good principle and ignore the $125-150/hour contract offers that keep pouring in and instead take a job making free software for 1/3 that amount? If I can even find such a position?

Sorry, I'm taking the money. You can make the sacrifice if you want.

>Microsoft will charge you for the privilege of using their inferior compiler

Express editions have been free for years. And that includes the entire VS suite as well as command line compilers.

>"Oh boy! B is giving me more stuff for free than A was, I'm going to go shit on A and make demands!"

Umm...hello? That's entirely unlike what I said.

What I said was: Lots of Free stuff sucks enough I'm willing to pay for closed alternatives. That's two kinds of payment: Paying with dollars, and paying with the restrictions in my freedom. And I'm saying the transaction is worth it. I'm not making any demands. I am saying that a lot of free software sucks compared to the alternatives, but that's just the truth.

In the case of Clang, it's awesome to me that it's BSD-free. If I need it in a piece of software, I can use it without question. Might it end up in a proprietary package? Yes. But if that user makes changes they'll likely send them back upstream so that other users of Clang will benefit.

> When I finally realized that the FSF is really about being a social movement and that creating useful software is a non-primary goal (or maybe even a non-goal), my level of annoyance with RMS greatly decreased.

Yes, that's pretty much it: http://www.gnu.org/philosophy/compromise.html

Context:

This discussion originated on the emacs-devel mailing list, where there was a discussion of adding code to company-mode (text completion) explicitly supporting Clang [1].

It was pointed out [2] that RMS has in the past shown a disinclination to incorporate Clang support into GNU projects because of his perception of its encouragement of proprietary software riding the coattails of open source (but not Free) software.

The discussion then turned [3] to another instance of this: RMS's disapproval of modifications to GCC that would have made the front end more easily separable from the back end, opening the door to a proprietary end-around (or just outright abuse) of the Free license on the GCC frontend.

The article linked above is RMS's response to ESR's comments [4] that such policies have reduced the popularity of GCC compared to Clang.

[1] http://lists.gnu.org/archive/html/emacs-devel/2014-01/msg017...

[2] http://lists.gnu.org/archive/html/emacs-devel/2014-01/msg017...

[3] http://lists.gnu.org/archive/html/emacs-devel/2014-01/msg017...

[4] http://gcc.gnu.org/ml/gcc/2014-01/msg00209.html

Clang is free software.

It[0] doesn't seem like a free[1] license.

[0]: http://llvm.org/svn/llvm-project/cfe/trunk/LICENSE.TXT

[1]: https://www.gnu.org/philosophy/free-sw.html

Edit: Yes, it is a free license, as other's have pointed out.

This is the NCSA/University of Illinois license. GNU classifies it as a free license: http://www.gnu.org/licenses/license-list.html#NCSA

Clang is also "a non-copylefted compiler that therefore becomes the base for nonfree compilers", which is the problem RMS has with it.

If LLVM is so bad why are the people who make it so much easier to work with? You shall know a tree by it's fruits. It wouldn't bother me one way or another whether LLVM was copyleft or not, the people who run it are more pleasant to work with.

I think the biggest hurdle to people caring about copyleft is the sheer tonnage of disrespect people like RMS show to others. Nobody wants to work with a curmudgeon.

If LLVM is so bad why are the people who make it so much easier to work with?

Who said it was bad? People have said it is not copyleft.

I think the biggest hurdle to people caring about copyleft is the sheer tonnage of disrespect people like RMS show to others. Nobody wants to work with a curmudgeon.

I think that's ridiculous. Do you really think corporate backers of LLVM would just ignore their economic incentives for a non-copyleft compiler if RMS was friendlier?

> Who said it was bad?

RMS.

> People have said it is not copyleft.

RMS says that it is bad because it is not copyleft. Specifically, he says "The existence of LLVM is a terrible setback for our community precisely because it is not copylefted and can be used as the basis for nonfree compilers".

Do you not think that "terrible setback for our community" is a subset of "bad"?

I interpreted "bad" in his post to mean "technologically bad" not "morally bad". On second thought, I might have misinterpreted his post. In that case, then the obvious answer to "If LLVM is so (morally) bad why are the people who make it so much easier to work with?" is that niceness and political ideology are only very loosely correlated, at best.

The other part of my comment still stands, though (I think).

The license is bad, not the software.

> If LLVM is so bad why are the people who make it so much easier to work with?

How is the license being bad influenced by, or of influence on, the attitude of the developers? Are you saying that surely the license can't be that bad, since the software is written by nice folks?

I don't think anyone said LLVM is technically bad; and there's no particular reason that pleasant people with good intentions can't be bad for a community that they don't explicitly identify with.

I think the FSF would argue that desperate cases require desperate remedies. You shouldn't expect your army to behave nicely at all times, even while defending your freedom. RMS isn't disrespecting others, he just has been at war so long that he isn't aware of their sensitivities.

What desperate cases?

The fight for users to be able to change their software, for example to add a 'print is done' feedback message to the software driving the print queue (http://en.wikipedia.org/wiki/Richard_Stallman#Background:_ev...)

I'm not convinced we're in desperate times. There are several significant open source communities built on copyfree licenses that flourish.

> If LLVM is so bad

RMS doesn't have a problem with LLVM because it's bad, he has a problem with it because it's good.

> the biggest hurdle to people caring about copyleft is the sheer tonnage of disrespect people like RMS show to others

No, the biggest hurdles to people caring about copyleft are by far the incompatibilities with accepted practices and existing software that make it a lot of work to comply with copyleft ideals.

RMS's tone never seemed disrespectful to me. Uncompromising and occasionally blunt, yes, but never disrespectful. What would you have had him do differently? Compromise his ideals? Spin out a comforting but insincere apology that focused on licensing technicalities rather than the underlying philosophical issues?

The problem with RMS is that he always assumes people to agree with his way of thinking. His uncompromising tone is also a big problem.

I know, programmers are supposed to be emotionless meritocratic robots, but this Old Boys Know Best attitude is precisely why RMS and GCC is losing user share so quickly these days: the extremist meritocracy of programming culture is actually highly male-centric, and it simply scares off all women and any men who are not sexists.

This is why LLVM is gaining so much support these days: it's technically superior, and its development community isn't sexist.

This isn't a problem with RMS. It's a fact of RMS, and such a well known fact that it practically defines him. People working on FSF projects tend to understand that.

If you actually read what RMS just wrote, or, for that matter, anything RMS has written in the last decade on similar subjects, it's clear that "losing user share" isn't a meaningful metric to the FSF. If you lose user share by strengthening non-free software, then there was no point to the FSF to begin with.

By starting your comment with "the problem with RMS", you might as well be pointing out "the problem with free software". Which, fair enough, but it's not like people didn't realize that non-free software could edge out free software on functionality or user-friendliness.

Still community needs such the persons.

>What would you have had him do differently?

The only code that helps us and not our adversaries is copylefted code.

I would have him not view people on the other side as advisaries. Sure FreeBSD and Konquer didn't gain much from Apple deciding to use their code, but they also didn't lose anything either. It isn't a zero sum game.

BSD and Konquer are not the adversaries to RMS.

People who threatens others with lawsuit for doing modification or sharing are adversaries to RMS. For example, he seems to dislike Apple because they threatens jailbreakers with million dollar lawsuits and jail, and do not want his code to contribute to that misery.

> Sure FreeBSD and Konquer didn't gain much from Apple deciding to use their code, but they also didn't lose anything either.

I disagree.

In fact, I think the GPL probably saved the World Wide Web.

That Konquerer was GPL was the single advantage it had over anything else. It used to be a buggier, and slower, and generally worse web browser, but every time someone made an improvement, the GPL made those improvements Free; When Apple improved it, it was the GPL forced them to make those changes available to everyone else, and while the code being available is what helped Google start their web browser, it was the GPL that fed those improvements back into the community.

Perhaps Mozilla (open source, but not GPL) would have remained an acceptable way to search wikipedia, but I struggle to believe it would become good enough to be embedded in nearly every operating system and WWW-capable device.

To be fair the Mozilla Public License is also copy-left it just uses a weaker (but also more clearly defined) barrier.

To be fair to whom?

People can and did extend Mozilla, and they can and did keep those changes non-free because the MPL allows for non-free linking and binary-only redistribution.

While the GPL does not.

>That Konquerer was GPL was the single advantage it had over anything else.

This is simply not true, and if it were, you'd be implying that Apple chose Konquerer over Mozilla because they preferred GPL to MPL. In reality, Konquerer had a much cleaner architecture that Apple thought they had a better chance of adapting to OS X.

The GPL had nothing to do with any of these events, the key feature was open source, not GPL. And if Apple had not turned Konquerer into a first-class user agent, Mozilla still would have had a first class open source user agent.

I think the web is one place where the GPL has demonstrated that GPL is not a key desirable feature in open platforms. GPL has had remarkably little to do with any of the web, as it is only used in one of three major user agents, and in almost none of the web-specific server stack.

I interpret geocar's point as being that the (L)GPL is the reason that Apple had to contribute the improvements that they made to Konqueror/KHTML back to the community in the form of WebKit: sure, they chose KHTML because of its technical merits but, having done so, they were obliged to make their improvements to the LGPL code available under the same license, thus allowing Google to use it in Chrome.

Actually, in the Debug podcast, it was revealed that they were going to go with Mozilla's effort and all that held them back was that KHTML was so much simpler to explain, though the simplicity was something it lost in rewrites. WebKit, regardless of original License, was likely going to be open source either way just as Darwin was even without the License requirement. The point here is that non-free uses inside OS X helped rather than hindered the development of KHTML software. By non-free I refer less to the availability of source code as to how copyright around branding forces a schism for normal folks between Chrome/Safari and WebKit/Blink projects. Few will download or trust a silver WebKit experimental build or blue Chromium over their official variants, particularly if functionality is crippled because of the lack of proprietary extensions that would normally ship or easily integrate. Sometimes FSF users simply aren't "the rest of us," which is why it's normal to have competing licenses. I hope this encourages both projects to become more active developing end-user appreciable features, though perhaps I'm more pragmatic that way.

> Actually, in the Debug podcast, it was revealed that they were going to go with Mozilla's effort and all that held them back was that KHTML was so much simpler to explain

Actually, that's completely irrelevant.

The GPL ensured that Google could benefit from Apple's decision to use KHTML.

That's exactly relevant! Your premise is that <insert entity> (in this case Apple) objects to releasing things free, and the only thing that made them do it is GPL. GPL is simply not relevant here, no one cared. Apple in turn benefited from Google's improvements of Webkit, etc. People who make decisions in companies, and indeed people in general, are perfectly able to understand the enormous benefits of cooperation. No need for any kind of force or coercion, thank you very much.

But there can be greater benefits of defection, particularly in the short term.

> the only thing that made them do it is GPL

That's the only thing making them do it.

Whether there are other benefits to giving away source code is not relevant. What they might have done is not relevant. No one could ever say whether Apple and Google and Samsung would have gotten together and made a web browser in collaboration without the GPL.

The fact is that they did not do it without the GPL.

Your argument, that GPL was KHTML's only advantage, doesn't make any sense because it then follows that Apple chose KHTML because they just love GPL and won't accept anything else despite KHTML's supposed technical inferiority. In other words, you're saying Apple chose KHTML because their only concern was apparently to get to be forced by GPL to release improvements. Because if KHTML was so inferior and forced them to release improvements (let's imply Apple didn't like this), what reason would they possibly have to choose KHTML? "Oh, look, there are these other engines which are better than KHTML but unfortunately their licenses don't force us to release our work, so no, we choose GPL."

In reality KHTML was a much better code base than other options, and Apple didn't really care that much about the license.

Let me tie in this comment with the whole thing about GPL vs. non-copyleft free software drama in general, and why I think GPL has become harmful: what you said I think illustrates a kind of thinking mode that the idea, the practical working principle, behind GPL breeds. The idea is to use force and coercion to make entities do what you want them to do. That road naturally leads to a mindset where every behavior is seen as necessarily motivated by coercion. And that leads one to normalize and accept coercion as an acceptable, even necessary, mode of social relations. I see this mode of thinking a lot with strong advocates of GPL. It's always in terms of someone being forced to do something good, and if they aren't being forced no good shall come out. This is a horrible, horrible way to look at the world. If we take Apple as an example, they open-sourced a lot of stuff they had no legal reason to release, some of those things very non trivial.

I have to point out that I'm writing all of this as someone who respects RMS and FSF's cause a great deal, I even use the term free software rather than open source (in my native language, fortunately, there's no confusion about "free", free as in freedom and free as in bear are not homonyms). However, I do not think GPL and strong copyleft licenses are an acceptable, or even a good way, to accomplish freedom in this domain of life. GPL is maybe a great tool to destroy proprietary software (well, almost, but not quite), but a horrible way to accomplish software freedoms in general.

relying on the goodwill of an entity will almost always get you nowhere. Apple (or any other major corporation) does what they do purely for profit - and of their decision to unilaterally release source code (without coersion from a license) is made based on the positive PR gains, on the fact that releasing software to commoditize the competition will help their own business, or for some other publically unknown reason.

It's always better to encode, into law, ethical behaviour we want, instead of hoping for it from people. Doubly so when the 'person' is a corporation.

I would have him not view people on the other side as advisaries.

"Competitor that through their marketplace success makes us further from our social goal" doesn't have all the same connotations as "advisory", but given their goals I don't see how it's not an accurate descriptor.

No, the software marketplace isn't a zero sum game. I'm not even a believer in free software, but it still frustrates me to no end when someone says "not a zero sum game" in a conversation that is so obviously about market share.

"Us" is literally the entire world, _including_ the proprietary software companies— up to the point where they start making encumbered versions of the program. So it is far from as simple as straight up competition.

It isn't about market share it is about users getting what they need. Sure you can measure users in terms of market share but that doesn't make it about market share.

To RMS and the FSF, what users need/deserve is Free Software.

> I would have him not view people on the other side as advisaries.

A big part of the impetus for the FSF was an early instance where they were adversaries, at least in RMS's eyes. The MIT AI lab had an open culture of sharing code, which was "taken proprietary" by several spinoffs in the early 1980s, who hired away some of the AI-lab hackers and stopped sharing improvements with the remaining not-hired-away AI-lab hackers. Stallman saw that as a bit of a betrayal of trust, not to mention damaging to the open development of software, and users' ability to have the source to & freedom to modify their software.

His solution was twofold: 1) start his own competing spinoff (the Free Software Foundation) which would employ its own set of hackers to develop the "public", non-proprietary codebase; and 2) license their contributions under a new license, the GPL, which would ensure that extensions to their code couldn't be taken proprietary.

I didn't mean bad as in poor.

I find it telling that RMS explicitly has a problem with LLVM because it helps private companies "as well as us" instead of only helping us. It's literally zero-sum for him. He doesn't want companies to benefit in any way from open source.

I think there's a big problem with copyright and software -- the goal of copyright is to provide public goods, but the public goods that copyright protects is the source code, not the binary, yet there are no guarantees that the public will ever get the source code. I think if this problem were addressed (e.g. all software that seeks copyright protection must have its source code placed in escrow) then a lot of RMS's legitimate issues with closed source software would be mitigated. I'm sure he would still resent code being closed source, but at least we'd know that in 25 years or whatever the source code would become available to all.

> He doesn't want companies to benefit in any way from open source.

He never said that, and you're really failing to see his point. He doesn't want GCC to be broken up into tiny bits and have each of those pieces replaced by non-copyleft equivalents. Because he doesn't want the hard work of the GCC community to be used as a scaffold for creating a non-free replacement.

He is totally happy for companies to use and benefit from GPL'ed software in all the ways the license permits. He is totally happy for companies to use and benefit from non-free open source software (like Klang) however they like.

He also has no problem with people forking GCC and splitting it up however they want to. He doesn't think that's a good use of resources, and he thinks it's harmful, but he has no interest in stopping them.

What is is not happy for, and what he is standing up against, is companies making changes to his branch of GCC. The GNU project is a group of people maintaining their versions of various Free Software. You can fork any of those projects and make different choices. But within the context of that project, amongst his collaborators he has opinions about what changes to make, and how best to further the goals of the project. And he thinks this change will be bad for the project.

I'm not sure if Klang is another software project, but if you meant Clang it is not non-free. Because it is not copyleft, its code can be used in things which are non-free. There is a distinction.

No, rms doesn't really care about source code. He cares about user freedom. He wants every user of software to have the same freedom to experiment, modify and redistribute that its original developers had. Placing source code in escrow would not accomplish any of these goals.

It would accomplish all of these goals in the long run.

I doubt that. Look at all the proprietary software that's abandoned right now. Are you telling me that if all that old source code was suddenly released it'd be every bit as good as software which has been free for the same number of years? Of course not.

> It's literally zero-sum for him.

Well it is. There are a finite number of consumers of C++ compilers. He is competing for the attention of potential free software advocates.

You're conflating "companies" and "creators of proprietary software". There is substantial overlap, but the "other" that RMS opposes is the latter.

> You shall know a tree by it's fruits.

Don't judge a book by its cover. Follow the money. A witty saying proves nothing.

Does RMS go trolling on dev lists for permissively-licensed projects? The FSF has been around for decades with the same goal. ESR comes in and starts needling over the philosophy behind the GPL on dev lists. Who's showing disrespect to whom again?

> Does RMS go trolling on dev lists for permissively-licensed projects?

Actually, he does. I remember when he went to an OpenBSD list a few years ago[1] and insisted they take out ports for non-free software out of the ports tree.

[1]: Too lazy to find the link.

> Does RMS go trolling on dev lists for permissively-licensed projects?

Are bears catholic?

https://groups.google.com/forum/#!topic/comp.lang.tcl/7JXGt-...

The people who campaign for GPL software authors to change their license seem to assume that the authors of the software naively chose the GPL, as opposed to choosing it for its particular spirit.

That's really important distinction that people don't realize about the GPL - it's designed to protect the rights of the END USERS. And that's great when the end user is you and me, but it's also not surprising that we, as developers, will happily throw end user rights under the bus if we think we can make some money (e.g. SaaS, app stores, etc.) or profit otherwise.

end users do not give a shit about source code (or software licensing at all).

Yup, I think that might be true.

However, I also think (I don't know for certain) that is precisely why it is important that the FSF keeps plugging away and refusing to compromise. There has to be one place where people do give a shit.

I have started to use gNewSense 3.0 recently. Small, fast, Gnome 2 and fortunately the er - maturity - of the packages does not affect my use cases.

Depends on who the end users are. The end users of clang might care about source code.

That's a pretty inane line of argument. Let's generalise it:

Xs don't care about Y, except for those Xs that do.

Insightful stuff.

End users that don't want to modify the source code them selves still have the option to use a forked version made by somebody else.

Well yes, that's the basis for Stallman's argument. If end users cared about free code, we wouldn't need to enforce it from the other side - nonfree software would have no users.

I care about free oxygen for all, but if the only way to get it was by buying it, I would still buy it, and applaud those attempting to enforce it.

It depends on who your end users are. They are not necessarily strictly consumers of software -- in fact, RMS' history clearly points to a concern for the rights of the interactive web of hackers circa the early 1970s. It is open for debate as to how relevant this focus is in today's very different looking software environment.

Software developers are also end users.

In fact I'd say this is one of the largest practical benefits for developers when it comes to GPL.

If a developer releases their code under GPL and someone else improves upon it, they as end users will recieve the source code to those improvements with which they can improve their original code or simply adopt the improved version.

I'm an end user. You probably are too. As an end user the GPL benefits me by granting me access to the code, to make alterations, to republish as I see fit.

Most end users don't care. Some do.

Do you have any examples where end users have been screwed by a program that was compiled using LLVM?

> a program that was compiled using LLVM?

Neither compiler affects the licences of the output. In the case of a compiler, the "end user" is the end user of a compiler (which in today's world is a developer, but 20 years ago may not have been).

End users are "screwed over" in this sense every time permissively-licensed free software is forked into proprietary versions that the users cannot do one of the following

1) Study (view the source) 2) Modify (edit the source) 3) Distribute (send the source or binary to another person) 4) Distribute modified versions of the software

All of these freedoms include the freedom to hire someone else to do this for you, so even if you are not a developer, you still have the potential to benefit from free software, the same way all drivers benefit from the fact that any mechanic can service a car (not just the dealer).

> Neither compiler affects the licences of the output.

Yes and no -- most programs use a c runtime/standard lib (libc). While both allow the use of differenc libcs, it's not quite clear that the gcc toolchain doesn't have any implications for the executable. Just being (overly) pedantic, not trying to contribute to the FSF/GPL FUD.

As for grand-parents point: the kind of scenarios where llvm is "scary" is for instance if a gpu vendor releases a closed compiler (or part of a compiler) for writing massively parallel code and/or shaders. Sometimes such a compiler might be called a driver, even if what it does is (among other things) compile code.

> Neither compiler affects the licences of the output. In the case of a compiler, the "end user" is the end user of a compiler (which in today's world is a developer, but 20 years ago may not have been).

Strictly speaking, the conditions of the GPL3 license apply to your GCC compiled code (using the GCC runtime library) unless it is compiled using an "eligible compilation process", i.e. no GPL-incompatible software in the middle:

http://www.gnu.org/licenses/gcc-exception-3.1.html

>The people who campaign for GPL software authors to change their license seem to assume that the authors of the software naively chose the GPL, as opposed to choosing it for its particular spirit.

Many do. Any many of them realize they didn't actually want the GPL, they just picked the license they had heard of the most. I don't see what this has to do with the discussion of gcc being limited technically because the GPL is not enough to sufficiently hinder people from writing proprietary tools.

>That's really important distinction that people don't realize about the GPL - it's designed to protect the rights of the END USERS

That is an artificial distinction created to try to justify the newspeak meaning of "freedom" where it is defined to mean "imposes restrictions". Developers are users.

> Developers are users.

Developers are users, but so are non-developers.

The question of whether developers should be able to restrict freedom of non-developers is the question of whether some users should be able to restrict the freedom of other users. This is an ethical (subjective) question.

Put another way, should landowners be allowed the freedom of having serfs or indentured servants? Not allowing them to do so is restricting the freedom of some people (the freedom to own serfs). But allowing them to do so is restricting the freedom of other people (the freedom to be... well, free human beings).

As a society, we believe restricting the freedom to be human beings is ethically abhorrent, so we have no qualms (anymore) about restricting people's freedom to own serfs.

Maybe you see non-free software as ethically abhorrent, the way slavery is, maybe you don't. But that is the axiom that the free software movement (and the GPL) is based on - to understand free software, you have to understand that principle, even if you disagree with it.

You are just repeating the same old red herring. Actually free software does not restrict anyone's freedom. I understand GNU/communists are insane, it is not a problem of understanding, but one of dishonesty. Pretending public domain software (actually free) restricts "end users" freedom is a lie.

"The people who campaign for GPL software authors to change their license seem to assume that the authors of the software naively chose the GPL, as opposed to choosing it for its particular spirit."

Sometimes they do. I've seen it happen more than once where developers chose the GPL, were asked to change it and then did saying they only chose the GPL because it seemed like a decent default because that's what Linux or whatever used.

Even more common are developers who don't fully grasp the practical implications of a particular license, like making a Go library LGPL without a static linking exception, not realizing that LGPL is basically the same as GPL on a platform without dynamic linking or a toolset that is well suited to distributing pre-compiled object files to satisfy the license terms.

And sometimes developers choose a permissive licence when they would have preferred a copyleft style licence had they realised the implications, same deal.

Now LGPL and Go's static linking can simply be about not grasping that Go statically links libraries into the final executable, as it's hardly the norm outside of Go.

Many authors do naively choose GPL, and many do not. It depends on the author's goal. If their goal is for as many people as possible to use their code then GPL is not the best choice. If the author places higher priority on the Stallman definition of free software then GPL is a great choice. Sometimes authors with the first goal pick GPL because they don't know any better.

> They have been supported by Apple, the company which hates our freedom so much that its app store for the ithings _requires_ all apps to be nonfree. (*)

This is a judgement of the motives of Apple that I do not believe is correct by Stallman and he making a straw man case for it. I don't think that Apple "hates" their freedom.

I do believe Apple added the restrictions on having only non-GPL code because they understand the problems that it presents legally in the App Store as a distributor and their bourdon under the GPL by being the middle man and redistributing the software in question. Apple would be required to field GPL requests for software in the App Store as the main distributor. This is risk and overhead Apple doesn't want to deal with.

They could just as easily make the language not specifically mention GPL at all but instead say that you releasing software on the App Store can't add restrictions, constraints, or additional requirements on how Apple distributes your apps in the App Store not expressly contained the agreement already. This would be the same and would be just as GPL incompatible as it is today.

Stallman is infamous for this tactic to the point it's getting tiresome for me.

Take a look at the thread on openbsd-misc "real men don't attack straw men" (his title) which was used to attack the OpenBSD project. They didn't stand for the crap stirring then.

Whilst I think his basic principles are correct, how he conducts himself is purely extremism and compromises those ideals instantly.

Edit: fix a couple of typos. Damn phone!

Distributions include src packages separate from compiled code, so why couldn't the Apple Store (or any store) do that? This isn't a legal issue; Google allows GPL code on it's app store.

Read what he wrote in the asterisk; he is making a distinction about DRM and terms of use.

A counter example: sourceforge, as the primary distributor of many GPL'ed binaries, does not have to field GPL requests for software. DMCA safe-habor clause removes that burden; all they have to do is comply with takedown requests.

http://www.openlogic.com/blog/bid/156894/Are-App-Stores-Liab...

"Either way, the next question in the legal analysis is whether the app store qualifies as an online service provider under the Digital Millennium Copyright Act (DMCA). Actually, a court may answer this question first as a matter or practicality.[1] The DMCA limits liability of online service providers for infringing material provided to the service by its users (i.e. app developers here) so long as the provider meets certain conditions. Whether an app store can be considered under the DMCA definition of an online service provider has yet to be tested, but it seems likely given the trend of caselaw that has held such vendors as Amazon and YouTube to qualify."

> A counter example: sourceforge, as the primary distributor of many GPL'ed binaries, does not have to field GPL requests for software. DMCA safe-habor clause removes that burden; all they have to do is comply with takedown requests.

Sourceforge can get away with that because Sourceforge has no editorial process.

Apple could not continue to operate their App Store in the manner they currently do and successfully pursue a section 230 defence under the DMCA.

Amazon got away with it and they have an editorial process for the Kindle store. Youtube takes down offensive videos and has a human appeals process.

The human appeals process wouldn't really factor into it. It's more about the distinction between "auto-posting anything submitted" and "high-touch pre-posting decision making process prior to posting" that distinguishes "safe harbours" from sites that bear responsibility for what they host.

I'd need to read the Amazon decision for more insight into how that played out. Seems like a somewhat unsettled area of DMCA caselaw.

That is an additional issue but only concerns GPLv3. GPLv2 is restricted for the reasons I mentioned above.

If you read his post, that isn't an additional issue, it's the issue he was talking about. If you read my post, you'll see GPLv2 isn't restricted for the reasons you mentioned because of existence and legal interpretation of the DMCA safe-harbor clause. Maybe you'd argue there would be a different legal interpretation for Apple. I doubt it.

If a company contracted out some code and the contractor stole it from some other copyrighted project, do you really think a court would hold Apple liable, unless there was some pattern of encouraging infringement in the App Store?

DMCA is afaik only valid in the US? So for Apple's stores in other jurisdictions it wouldn't matter?

As for the GPL being a problem for SF in the first place, that sounds odd to me -- isn't that like saying that the company I'm leasing a VPS from is a distributor of the software I make available from my site? Obviously there's a distinction, but it sounds odd that SF should be considered a distributor?

> This is a judgement of the motives of Apple that I do not believe is correct by Stallman and he making a straw man case for it. I don't think that Apple "hates" their freedom.

I think Apple views freedom as a threat to their business, so if companies are capable of "hate" then I think the statement is accurate.

Apple doesn't view 'freedom' as a threat. It views crappy user experience for regular people as a threat, and it fears that if it doesn't exert control over the ecosystem, that will be the result.

> I do believe Apple added the restrictions on having only non-GPL code [...]

Apple allows GPL code in the App store. There are many GPL apps (both GPLv2 and GPLv3) in the store.

If you are using GPL code that you do not own in your app, you do need to get a non-GPL license from the owners to allow Apple to distribute it, and so the code ends up dual licenses--special license for Apple, GPL for everyone else.

Well yah, if you have ownership, you can license it under all the terms you want to different people. Kind of moot.

It's not moot at all. Your statement, "I do believe Apple added the restrictions on having only non-GPL code", implied that all licenses on the code must be non-GPL.

Is it bad I just don't care that LLVM has enabled non-free software? Because it has done a h*ck of a lot for opensource software. New languages, new compilers, new optimisers, new IDEs have sprung up around an impressive framework.

I also don't understand how LLVM enables non-free software any more than binutils does. I can do:

  binutils/cat my_file | my_incredibly_none_free_program | binutils/grep my_pattern

which is essentially how LLVM works.

No, it's not bad. Stallman is an ideologue.

You feel the need to censor "heck"?

Seriously though, I agree. Stallman here seems to be adopting almost a religious argument, not a pragmatic one. He even announces a refusal to use Skype because it's not free software. If he prioritizes freedom over everything else, then more power to him, but to me talking about who "wins" and "loses" on some kind of arbitrary scale of freedom does not make a compelling case against the use of excellent tools like Clang/LLVM.

I think that's the function of Stallman and what he will be remembered as: an absolute that's useful to measure your own position against.

I agree. Also it serves to be notable so people keep talking about it.

He even announces a refusal to use Skype because it's not free software.

Which is a valid complaint given the nature of Skype. There's also tons of other reasons, though. Primarily technical ones.

Either way, software freedom is an important goal and even though I don't necessarily agree with RMS in this case, I understand where he's coming from. So many people seem to have some phobia of accentuating the ethical, freedom and community contexts that the term "free software" implies, preferring the more bitterly pragmatic "open source".

That and this is a very typical RMS rant. This is probably the umpteenth one of the same variation, only with $SOFTWARE being Clang/LLVM in this case.

For the record, I love Clang/LLVM and support BSD licensing. For a lot of software, having an open source development model without the deeper freedom contexts is good enough.

Re Skype: He also suggests just making a normal phone call. Which has pretty much the same problems: It's an opaque, closed system with pretty much the only difference that there are multiple companies controlling it instead of just one.

I don't think that's true. Phone systems are standardised. There is also free telephony software (like asterisk). The cell phone stuff is more secretive, but it's still more open than Skype, which is completely obfuscated, proprietary and centralised.

I would only add that I can own my phone. I can not own my own skype client.

The complaint about using phone would be much better suited for 1950 where "the phone company" owned the phone. You called, was asked to choose between 3 different colors, and then a few days/weeks later they came and installed a phone with the clear label that said "property of the phone company".

Dude. rms founded the freaking FSF. If he doesn't support free software, then what the hell is he doing? I think what he wrote here makes total sense, even if I use tons of nonfree software myself. I value convenience and performance more than rms does - to him, freedom is much more important.

I think his argument is just that the whole point of GNU and the FSF is to make free software - if they compromised on that, then what would they stand for? And I think that argument makes perfect sense.

You've got to admire RMS for that. In the previous email, ESR is essentially saying "GCC is doomed if it doesn't change, it will be legacy" and RMS response is one of no compromises.

I respect that, even though I disagree almost completely and have no alignment with what the FSF proposes.

I understand that he needs and wants to support the cause of free software, but you can do that without making the hyperbolic statements he is making. Being as ideologically rigid as he is can be counter-productive, as people like me are less likely to take his arguments seriously if they seem to be founded more on dogma than sound arguments.

RMS has a ideology of what free software is that ignores how much 'free' software actually gets delivered to users. As an example XCode is not free but since Apple can make an ecosystem around LLVM/clang it creates the profits necessary to pay developers to put lots of work into LLVM/clang that people can use under a BSD/MIT license.

RMS has a kind of natural law approach to freedom while most 'free' countries have a limited amount of freedom that people give up in order to have an organization that guarantees the remaining freedoms. RMS is much more concerned about maintaing ideological purity than implementing a less ideologically pure system that may or may not benefit users more.

Fundamentally once GNU code supports clang, GCC dev stops because it's codebase a horrible mess.

> Is it bad I just don't care that LLVM has enabled non-free software? Because it has done a hck of a lot for opensource software.*

This presents an interesting (to RMS) quandary. I take it as a given that he prioritizes the freedom of software over its technical merits (as discussed in other threads). But, even just from the freedom perspective: LLVM increases the amount of proprietary software produced, and also increases the amount of free software produced. Does RMS consider this a worthwhile trade-off? Or does he think that less software overall, and less free software in particular, is favorable to more free software existing and also some proprietary software.

RMS appears to believe that the creation and distribution of non-Free software is a categorical and unscionable evil, such that anything that anything that encourages it (whatever other benefits it provides) is categorically morally wrong, and anything that discourages it is categorically morally obligatory.

There a bunch of facts that contradict this, e.g. the exstance of the LGPL, RMS supporting BSD licencing of Xiph codecs etc.

His approach is a lot more nuanced and tactical than it is often portrayed.

> There a bunch of facts that contradict this, e.g. the exstance of the LGPL, RMS supporting BSD licencing of Xiph codecs etc.

Those don't actually contradict it in any way that I can see.

> His approach is a lot more nuanced and tactical than it is often portrayed.

Sure. That doesn't mean that the long-term goal isn't as I've described it (and, in fact, RMS has pretty explicitly said it is for him, though that may or may not be true of the FSF.)

The LGPL is explicitly designed to allow non-free software to be created that uses the code under that licence, and it was created by RMS.

He supported BSD licences for Xiph codecs because he recognised the impact of network effects,

You claim that both these thing are considered "evil", "unconscionable" and "categorically wrong" by him regardless of whatever benefits they create. Clearly RMS disagrees, and is happy to use them as tools to achieve his long term goals in specific circumstances.

In the context of compilers, the harm of non-free compilers are not just speculations. The EU came down with large fines against intel when they did anti-competitive behavior in their compiler. If the intel compiler had been provided with source and under a free license, this anti-competitive harm could not have happened.

RMS is a proprietary software obscurantist in general and goes as far as opposing that proprietary software even be mentioned as an alternative.

He makes a lot of good points and is very aware, but his extreme ideological dedication is what drives people off. Which is a shame, because he's done a lot to convince and further adoption of free software in government and education, plus there's plenty of things one can learn from him.

He even touches that directly:

> The existence of LLVM is a terrible setback for our community precisely because it is not copylefted and can be used as the basis for nonfree compilers -- so that all contribution to LLVM directly helps proprietary software as much as it helps us.

... which pretty much is the answer to your last question.

He assumes that helping proprietary software is a bad thing (well, more accurately, he asserts this axiomatically). However, proprietary software can have many benefits. Many if not most successful software businesses have made great contributions to open-source and the development of free software. I know for a fact that a huge amount of linux development is driven by for-profit companies. If a company can make a profit, make an excellent product, and pay it forward by contributing to open projects as well, it sounds like a win-win to me. This might violate RMS's axiom that only free software is good, but as Hitchens says, "What can be asserted without evidence can be dismissed without evidence."

You're right, I had missed some of the implications of that statement. Basically, he considers the additional free software created to be a negative rather than a positive, because it gives an even bigger benefit to proprietary software.

>Or does he think that less software overall, and less free software in particular, is favorable to more free software existing and also some proprietary software.

You can create proprietary software _with_ GCC just fine, and he has never proposed any measures with which to impose any restrictions on the final output binaries you create with GCC so I don't really follow your reasoning.

The 'problem' with LLVM from his view is that it is easy to incorporate into proprietary software, as well as easy to use in conjunction with proprietary software (through plugins for instance), which means that there is potentially much less incentive to contribute your code back when it's easy to maintain it in proprietary form, which then leads to less 'free' software.

His cynicism has a tendency to come true, so it will be interesting to see if LLVM open source development will continue to flourish or if we will see a slow but steady transition of 'real improvements' happening in proprietary plugins or forked versions rather than contributed back to the open source project.

In some ways we might be seeing it already, last time I heard (which was in september IIRC), Apple had not contributed their A7 support to the open source versions of Clang/LLVM, and are instead keeping it proprietary and only available on the Clang/LLVM versions they ship with XCode on their OSX platform.

I am glad you don't care. I do care. good argument. cats are over there ----->

I invite those working on major add-ons to LLVM to release them under GNU GPL version-3-or-later.

I don't use the GPL because I cannot honestly say that I understand it entirely. I understand copyleft, but the document is written for lawyers and I am not one. I can't expect users to read it either, much less understand it.

I use the BSD licenses because they are simple and clear. If I ever had to defend my intellectual property, I could do so myself, and the case would be over quick. That is more important to me, as a developer without access to lawyers, than ideological battles.

http://www.gnu.org/licenses/gpl-3.0.html it isn't that bad to get through. There are also more than enough analysis of it on the web from reputable sources (I'm looking for good links...).

If you understand copyleft, then you know what you're giving up by not using a copyleft, license. Do you not care about what you gain from the copyleft or don't want what you gain?

I care about what I lose because of copylefting software. I want software to suck less, and if that occasionally means letting someone be a free-rider on my stuff, let it be. At the same time, the existence of the GPL doesn't preclude people from free-riding either. Look at the embedded toolchains that are little more than GCC with a tiny proprietary wrapper, or the many many companies that use GPLed code, and have internal patches that never see light outside of the company. Restrictive licenses like the GPL are not all sunshine and roses.

I think most people outside of technology wouldn't easily understand copyleft, and a day might come when I depend on those people. So it's a trade-off between my rights, users' rights, and my peace of mind. The rights I give up, by choosing BSD rather than GPL, I don't think I could enforce without losing my peace of mind.

> If I ever had to defend my intellectual property, I could do so myself, and the case would be over quick. That is more important to me, as a developer without access to lawyers, than ideological battles.

The case would be over quickly, but you may not be happy with the result.

If you are not well-trained in copyright law (specifically as it applies to software), you are not going to be able to enforce the BSD license any better than you will be able to enforce the GPL, without a lawyer. There are just so many other ways that a well-funded legal team can give you the run-around.

The whole point of BSD-style licenses is that there is hardly anything to enforce at all. With such a license you are simply stating that you allow the receiver to do whatever they want with it. This statement is just necessary because by default under the copyright law no rights (with some exceptions such as fair use etc., it depends on jurisdiction) are granted to entities receiving the work.

Well, yes, obviously it's "easier" to litigate when you give yourself less legal standing to file suit, but that's a rather meaningless comparison. By that logic CC0, is the easiest to litigate, because you've given up all your rights as the license holder. That only makes sense if you place literally zero value on the rights that the license provides. It's only relevant to compare how easily enforceable two licenses are when the rights they provide are comparable (e.g., GPL and MPL, or 3-clause BSD and MIT).

The whole point of choosing the GPL over BSD/MIT is choosing a copyleft license. If all you care about is ensuring that the recipient is legally granted the rights provided by the BSD/MIT license, then the question of how "easy" it is for the license holder to litigate isn't relevant.

OP's argument was that it would be too much mental effort to enforce the GPL, though that's not really an argument for not choosing the GPL, because simply holding the license doesn't mean he has to enforce it.

If OP actually doesn't want the copyleft provisions, then obviously he shouldn't choose the GPL. But if that's something that he does care about, there's not really any downside to selecting the GPL, and no upside to selecting a non-copyleft license.

In case anyone doesn't realize this: the ARM64 LLVM backend used by Apple in Xcode 5 to target, for example, the iPhone 5S, is currently not open source. There is a vague promise that it will be merged, but the time frame described was itself long, many months have already passed, and it doesn't really seem like much progress has been made since (although of course things could be happening internally at Apple).

(In fact, none of the code actually backing Xcode 5 or iOS 7, even LGPL code such as WebCore/JavaScriptCore, has yet to be released; but, in the case of the ARM64 backend, there was a specific discussion about it on the mailing list, and in fact some iOS-specific ARM64 patches to LLVM languished seemingly due to the idea that "well, some day the ARM64 stuff will be merged from Apple", so it is already having "chilling effects".)

This message conflates two issues in an unfortunate way. One issue is the licensing of GCC, the other issue is the architecture of GCC (how modular it is).

No one is arguing that GCC should change licenses. But he seems to think that making GCC more modular would somehow make it less free:

> If GCC were to change from a free compiler into a platform for nonfree compilers, it would no longer serve the goal of freedom very well.

There are two embedded assumptions here. First, that making GCC more modular would result in people creating non-free compilers with it (presumably by connecting a non-free component with GCC using an IR rather than linking directly, to get around the GPL). And second, that such use would become more prevalent than just using GCC itself (which is what would "change" GCC from a free compiler into a platform for nonfree compilers).

I imagine a few people would use GCC components that way, if it became more modular. But would that use be a significant one? That's unknown. And would that use "no longer serve the goal of freedom"? If a large number of nonfree tools appear that generate and consume a GCC IR, that could boost GCC as well.

The GPL seems to be able to defend freedom just fine for all the other gnu software, even the modularly-architected projects. I don't see why it can't ultimately do the same for GCC.

This is a good take on the deficiencies of Stallman's position here really.

Linus stands directly against this sort of idea - his whole take on licensing has always been that he wants to make sure people contribute code back if they modify it, but otherwise can include the kernel in whatever they want - which provides a similar benefit - more people using Linux kernels, more people likely to want to improve Linux kernels.

More people using GCC would be great - especially since any 'magic' blackbox components that became useful would start to expose their workings anyway since they'd have to speak to GCC.

>Linus stands directly against this sort of idea

Linus and the rest of the Linux kernel developers make it intentionally hard to keep out-of-tree modules working against the kernel for the same reason that GCC does, which is to have the code included into the main project where it will benefit all end users instead of having proprietary/out-of-tree modules/plugins which are available to a select audience.

I can't see how you can claim that Linus stands 'directly against this sort of idea'. They seem very much aligned to me.

That's a different problem - namely that they don't want to tie Linux to having a stable ABI.

The side-effect is that it makes it difficult to maintain out-of-tree modules, because people don't fix things as they edit the kernel (if it builds, it builds etc.)

No they are deliberately adding GPLONLY symbol restrictions to prevent proprietary linking with the kernel, which has nothing to do with keeping a stable ABI.

They can keep the ABI as unstable as they want while still allowing proprietary linking, they don't have to provide any maintenance help to proprietary vendors who wants to link to the kernel.

I've seen the argument made that somehow RMS and the gcc developers are against making gcc more modular. Where is everyone getting that idea, because that's not what I'm reading.

Indeed, this quote from David Edelsohn in response to ESR seems to indicate they are interested in making the gcc more modular:

>GCC is working toward re-factoring its code base toward a more compositional approach for "toolification". One can look at presentations from the recent GNU Cauldron 2013 for discussion of the topic.

So what am I missing?

[1] -- http://gcc.gnu.org/ml/gcc/2014-01/msg00212.html

"Anything that makes it easier to use GCC back ends without GCC front ends--or simply brings GCC a big step closer to a form that would make such usage easy--would endanger our leverage for causing new front ends to be free.

Because of this, the GNU Project will in all probability not install such changes, should they be available. This statement reflects a firm conclusion based on a decade of thought."

http://gcc.gnu.org/ml/gcc/2000-01/msg00572.html

That's 14 years old. The GP's message is from this year.

He's basically saying: "We must avoid design decisions that allow users to do X, because we disagree with X".

Everyone has their own definition of "Free", but to me that seems very similar to Walled Garden decisions regarding my freedom as an end user. You could just as easily say:

"We don't want to allow unsigned code to run, because we disagree with not signing code"

I guess the difference is that you can fork gcc and start a parallel project. Or you can just let it die as llvm and clang become more and more efficient.

Is this still surprising or non-obvious, after decades of GPL vs BSD flamewars (and, in particular, discussions on which one is truly "free")?

GPL is restrictive and defending users' freedoms is the exact reason for this. If you care about that, welcome to the GPL side; if you don't want the imposed restrictions but also ready to stop enforcing (through restrictions) GPL-granted freedoms - BSD and company await you.

> Or you can just let it die as llvm and clang become more and more efficient.

That's my plan.

>I guess the difference is that you can fork gcc and start a parallel project. Or you can just let it die as llvm and clang become more and more efficient.

And watch as over a decade or two you lose any control over what software you run that you still might have.

>He's basically saying: "We must avoid design decisions that allow users to do X, because we disagree with X".

Well obviously he wants to void design decisions which allow limiting end user rights given that protecting these end user rights is the entire idea on which FSF and subsequently the GPL licence was founded.

Rights which include the source code to see how a program works and be able to modify, run and copy said software.

Allowing for proprietary plugins in GCC means no longer protecting these rights, which of course makes no sense from FSF's standpoint as again, protecting end user rights is and creating software which promotes these end user rights is their reason for existance.

Stallman consistently ignores the free market when writing about software freedom. What users want, the free market will provide. If they want customizable software, the market will give it to them. If they only want feature X, the market will give it to them. If they want interop., they will get that too. If they don't care about modifying the source code, well, people won't offer it.

The GPL is not what allows users to get what they need from software or technology. It's the market. As long as you have a free market, with able competitors, you don't need the GPL, and the whole discussion of "free software" is a red-herring.

Stallman's initial experience with closed software was not in a free market, so I can see how he's grown up with a colored view.

He also got a million dollar grant from the McArthur Foundation, and another one from the Takeda Foundation, and doesn't really understand that most programmers operate in a very different economic reality than his bubble.

ESR, is that you?

All you did was repeat "free market" a bunch of times. Congratulations.

Besides that, I'm pretty sure when the free market sent down that 10 commandments thing it said not to go around using it's name in vain

Allow me to continue, then. Stallman's original problem was essentially, "I had a broken car once and I couldn't get the part I needed to repair it. That sucked, so all manufacturers should provide everyone with all the information needed make any replacement part."

In today's world that problem really doesn't exist anymore. Software is a mass market product, and the software that is produced already conforms to what people want pretty well. Sure, I'll take cheaper parts for my car, but on the list of humanity's problems, non-GPL software is very, very low.

Your ignorance is baffling. I won't continue to humor it.

When do you think the shift from a non-free to free market happened? What brought it about?

It's a function of the size of the market. When Stallman was programming computers, the number of computers was quite small and it was much more expensive to create software. These days, especially after the PC revolution, creating and modifying software is much cheaper, especially relative to the demand for software, which is much higher.

Do you think the widespread availability of a free and high quality compiler had something to do with the PC revolution?

No. The PC revolution was built on compilers like Borland's Turbo Pascal and Microsoft C. GCC was very much a latecomer to the PC revolution.

The free market, what a great idea. Producing great things such as skyrocketing health care costs, the mortgage crisis and others...

Those problems are the result of heavy government restriction and bailouts - the exact opposite of a free market.

What many GPL supporters fail to understand is that GPL doesn't hinder or hurt big companies at all. If they find a GPL-licensed piece of software they need, they just pay their developers to make another proprietary one. With the exception of huge projects like Linux, it's a rounding error for them.

No, the only ones the GPL hinders are small-time freelance devs and small devs shops who are trying to make a living. Often, these are the same devs who are leading open source projects of their own. When they need to create a proprietary project to pay the bills, a GPL-licensed library is usually the end of the road for their project, since they won't have the manpower to replicate it on their own.

Aside from these issues, do we really care that we can't access the source of Subtle Text? As long as it's got a good API, I don't see the big problem. Don't get me wrong, I'm a strong supporter of open source, and have realized numerous modest projects under the MIT license. But proprietary projects, even ones that use my MIT code, don't offend me to the core like they do RMS and co-ideologues (incidentally, I feel like I'd really get along with RMS as a person, even if he might shun me).

tl;dr: “I disagree with the core principle of the FSF and the GPL”.

Nothing particularly new here, but it's another reminder about the actual goal of Free Software. A lot of people still don't understand the major distinction between Free Software and Open Source.

Every once in a while, RMS makes a statement that doesn't require translation to avoid seeming ridiculous:

"When any program fosters non-free software, that works directly against the overall goal.

"Copyleft is our method of making sure that our free software does not generate nonfree competitors which consist of our code plus something else that is off limits to us."

http://gcc.gnu.org/ml/gcc/2014-01/msg00208.html

> The values of free software are fundamentally different from the values of open source, which make "better code" the ultimate goal.

I want to live in a world where innovation thrives and survival of the best technology reigns. Because the ultimate point of technology is to serve humanity by making our lives better. So stifling innovation just so that everyone has access to source code is backwards.

the point is -who is "us"?- us the developers? us the government? us the users?

The rough line of reasoning here is that non-free software will, eventually, allow business tactics which run counter to software thriving and the best technology reigning.

> [Clang and LLVM] have been supported by Apple, the company which hates our freedom so much that its app store for the ithings _requires_ all apps to be nonfree.

It's worth pointing out that GCC also "has been supported" by Apple, especially around PowerPC support and the PFE implementation. If you can get past the insane "War on Terror" rhetoric, that is.

It's worth pointing out that Steve Jobs at NeXT was a prime example of the benefits of a policy against proprietary linking as Jobs tried to have GCC be the backend of their (NeXT's) proprietary ObjectiveC front end.

He (Jobs) was not allowed to do this due to the licencing (GPL) which is what led to GCC getting a ObjectiveC frontend merged which was then available to all GCC users.

Had Jobs had his way, only NeXT users would have had the benefit of the ObjectiveC front end while NeXT would have enjoyed the benefits of the GCC backend.

Well, when you spin it like that... I'm no Steve Jobs apologist, but I think it's important to get the facts straight. NeXT wanted to distribute the frontend as .o files which the user would link with the backend, true. Now, the way you present it makes it seems as though NeXT was hell bent on having a proprietary frontend, but were strongarmed by the GPL to release under the GPL. What actually happened is that Jobs asked RMS if he thought it would be OK to distribute the frontend as .o files, to which Stallman said that it probably would be OK (from a legal standpoint), but then consulted a lawyer who told him that the judge would probably think this is not OK. So RMS then tells Jobs that FSF believes this is not allowed by the GPL. Then NeXT produces GPLed frontend. Notice how smooth all of this went. No attempts of subversion by NeXT or disputing FSF's opinion, they asked, were given a legally worthless negative opinion which they accepted and produced a free frontend. So yes, technically it happened because of the GPL (but only on an assumption that the judge would accept FSF's lawyer reasoning) but based on what actually happened there is no evidence of Jobs wanting to "have his way". If Jobs "hated" "our freedom" and the GPL was the only thing that stood between us and slavery as RMS likes to think, this would unlikely go without any friction whatsoever.

Sources for what happened: http://www.gnu.org/philosophy/pragmatic.html http://www.tikirobot.net/wp/2008/11/22/why-gcc-has-a-free-ob...

EDIT: Another source, the first paragraph is telling: https://groups.google.com/forum/#!topic/gnu.misc.discuss/_pB...

I am surprised he isn't railing against all the folks selling GCC for extortionate rates to the embedded community. IAR, KEIL, others, $3,000 - $6,000 for a "development tool" which is 99% gcc and 1% some startup code the vendor wrote. Nice margins I guess.

This is perfectly valid, selling GPL software is fine if you can find someone to pay for them. Wrapping them up in a nice installer and selling a support package, also A-OK, and a frequently recommended business model. Free software doesn't mean free as in price, it is free as in freedom.

Keil is a bit different in that you are also paying for their IDE and debugger and such, which are of course non-Free.

  >> 99% gcc and 1% some startup code

Modifying and selling gcc to compile code optimized for lots of different underpowered processors sounds like an unattractive business model to me, given (I assume) a relatively small number of customers for any given microprocessor type and (again I assume) a significant amount of work for each microprocessor type supported.

Sort of. There are folks who have C compilers optimized for smaller processors, my personal favorite are the folks at ImageCraft. That isn't what I'm talking about.

I'm talking about people who take the community developed gcc (which they haven't "optimized" at all) and Eclipse config, and some of their own startup code crt0.a + linkerscript. And then put that together as their tool for $3,000. I'm sure its a wonderful business for them.

RMS was railing that clang wasn't embodying the spirit of "free software" because it parts could be proprietary, but he doesn't rail against those people like IAR who keep their parts proprietary but are riding on the shoulders of the community doing the heavy lifting.

I find that notable because I like what the folks are trying to achieve with clang and do not like what IAR has done with gcc. Granted it is entirely my own personal pain point.

"The existence of LLVM is a terrible setback for our community precisely because it is not copylefted and can be used as the basis for nonfree compilers -- so that all contribution to LLVM directly helps proprietary software as much as it helps us."

See, this is why I hate Stallman's position on anything software. It's based on irrational thinking derived from a flawed ideology.

Since LLVM is not copylefted, EVERYONE is able to benefit from it, and that is good... FOR EVERYONE! For example, NVIDIA based their CUDA compiler on LLVM because it was not copylefted. Thanks to LLVM not being copylefted, NVIDIA was able to reduce their R&D time, provide customers with great technology, and consequently sell more products. The money that proprietary companies make from being able to incorporate non-copylefted software into their products has a ripple effect. Companies like NVIDIA can provide more jobs, LLVM developers become more highly sought-after, customers benefit from more rapid advances in the technology, and the entire LLVM-based community benefits from work that filters back down from companies like NVIDIA into the mainline LLVM repo.

Stallman's argument that projects like LLVM help proprietary companies take away users' rights is simply not true. There would be little benefit for a company like NVIDIA to take from the LLVM community, and be unwilling to give anything back. For one, it would be so much harder for them to hire good people out of that community, which they will desperately need in order to drive their products forward. But look at what has actually happened: NVIDIA are releasing the code to their LLVM-based compiler! Why? Because it doesn't really benefit NVIDIA to enforce a proprietary lock-in on their customers.

As for his argument against the Apple App Store, how is it really of benefit to anyone if binaries are "free" the way he thinks they should be? Does anyone really want or need the ability to install a "free" binary onto their iPhone/iPad? Why is wrong for companies to want to protect their proprietary platforms and technology (and also their users) from potentially malicious/illegal code, or code that might brick the device? Oh, that's right! Because Richard Stallman thinks that companies should not be allowed to guard any of their interests when it comes to software. This is an obnoxious opinion, and detrimental to real user freedom.

I do not think the world will suffer AT ALL if clang/LLVM has doomed GCC to irrelevance. I was actually glad to read Stallman's email because it signifies that clang/LLVM really are eroding GCC's relevance, to the point where even Stallman is feeling it. Soon, Stallman and his FSF cronies will be relegated to the footnotes of computing history where they belong.

NVIDIA benefits from LLVM at the expense of user freedom. That is not benefiting everyone. You, like many others, value convenience over freedom. The Dead Kennedys have an album entitled "Give Me Convenience or Give Me Death". That title reminds me of the dominant mentality in the software industry.

You seem to have forgotten that computers exist solely for the purposes of making man's life more convenient. Any ideas of software freedom that get in the way of this convenience are bad for mankind. Therefore Stallman's ideas about software freedom are bad for mankind. LLVM is more popular because it is more convenient. It is more convenient because it is truly free, and not enslaved by a license that exalts the "rights of software" above all else.

The idea of imbuing an inanimate thing with rights that are restrictive to animate beings is philosophically offensive to any right-thinking individual.

Granted, the application of the adjective "free" to an inanimate thing like software is confusing. But the point of free software is to promote freedom for the users of the software. So it really is about freedom for animate beings after all.

> For example, NVIDIA based their CUDA compiler on LLVM because it was not copylefted. Thanks to LLVM not being copylefted, NVIDIA was able to reduce their R&D time, provide customers with great technology, and consequently sell more products.

Counterpoint: Say I'm writing a new OS, and want to use the hardware I bought. How do I port the CUDA compiler? Porting GCC (or LLVM) should be pretty easy -- but that doesn't help me, because I can't use my software on my hardware.

This is what RMS has a problem with. You argue that if they had to contribute their changes back, we would all have been worse off. I'm not so sure. I think it's more: Nvidia could get lots of code for free and made more money, than if they had to write that code themselves. Great for Nvidia, yes -- but it's a bit of a tautology: If I give you something for free, and you can turn around and make money off it -- that is good for you. It's a bit of a stretch to say it's a lot better for me.

Do you not benefit from newer technology delivered at lower costs? Do you not benefit from more paying jobs to work on open source software?

What RMS has a problem with is the fact that companies don't (and shouldn't) always tell you how their products work. Just because you bought something doesn't give you the right to know all of its secrets. If he (or you) is not ok with that, then fine, he lives in America, he has the freedom to disagree. His solution, however, is to try to restrict the freedom of people and companies when it comes to software and software reuse. That's what I have a problem with.

Thankfully, I think LLVM and clang represent the coming ultimate triumph of the Berkeley school of software freedom. The clouds of the Cambridge school have overshadowed the software world for far too long.

As I try to support companies that work for a more open architecture, no, I do not benefit from proprietary advances by Nvidia. I would also argue that free research, open technology in general leads to lower costs and higher productivity than closed equivalents -- while they might lead to lower profits (and less concentration of wealth). But since I don't own Nvidia, I don't benefit from their profits.

RMS has just made a choice that he'd like to do his bit to enforce openness and freedom. Everyone is still free not to use GPL software, just as they are free to not use proprietary operating systems. And without the FSF and RMS, I think we'd have a lot less choice in that regard.

There's lots of paying jobs for working on free software too -- we can (and do) have both.

As for:

> Just because you bought something doesn't give you the right to know all of its secrets.

Perhaps not. But I'd argue you should have the right to use it as you see fit. I don't need to know all the details of a chair to sit on it, use it to reach the top shelf, or burn it to keep warm -- to use it as intended by the manufacturer and otherwise. I do need to know a bit about my graphics card to use it efficiently.

It's interesting that the advantage for LLVM is that it was used to create a compiler for a processor with a secret and proprietary instruction set.

If NVIDIA had to use GCC (surely they'd have just done their own instead, but for the sake of argument) then we'd all get to learn more about their architecture and maybe make compilers for different languages that natively target their processors...

What makes you think you have the right to learn about a proprietary architecture? Just because you bought the product doesn't mean NVIDIA has to tell you how it works.

I respect RMS a lot and really appreciate his steadfast promotion of free software (copyleft). But isn't it becoming a moot point in this day and age? A decade or two ago the software tools were important and since all of them were proprietary GNU was sorely needed and all the work done by people on GNU and Linux really was needed. But now the concept of open source and free software (not copy left but just free) has really taken roots and businesses have evolved to circumvent the revenue loss from giving away software. Instead they now created a new closed ecosystem - cloud and hosted services. By moving them away from people's computer they have control and we are pretty much in the same situation as we were a decade ago. So we need a new idea of "copyleft" that applies to services and hosted platforms and not just tools. Isn't it where the battle needs to be now with regards to freedom (as RMS puts it)?.

And RMS recognizes this. See https://www.gnu.org/philosophy/who-does-that-server-really-s...

"[The Clang and LLVM developers] object to the measures we have taken to defend freedom because they see the inconvenience of them and do not recognize (or don't care about) the need for them."

I would call this an Orwellian use of language. Stallman and the FSF have adopted a particular definition of "freedom", which is a good deal more particular that the usual definition, but they seem to consistently act as if it was the one and only definition, and therefore that anyone opposed to it is opposed to freedom.

Nevertheless, on one reasonable definition of "freedom", permissive licenses are more free than copyleft licenses. On another reasonable definition (the FSFs), copyleft licenses are more free than permissive licenses.

The statement quoted above implicitly assumes that there is only one definition of freedom, and it's the one the FSF favors.

Obviously you've never read RMS, because "open source" is one of the things he vehemently fights against.

How does Stallman fund his life? I'm assuming he gets paid a salary. So he's ok with doing work for money himself, but not ok with other people monetizing their efforts in a slightly different way. I don't understand.

> How does Stallman fund his life? Probably with great difficulty, but looking at the guy I bet he's never even seen a suit and tie. Also because of his views on privacy, I think speculating what his average drawings are is a waste of time. I don't think he uses a mobile phone, so what are the chances of him waving his T-accounts in the press' face?

He does not get paid a salary, afaik. The FSF certainly does not pay him. In the old days he made his money by selling copies of Emacs and documentation and such. These days, he travels the world and speaks at various institutions. Monetization is not at odds with free software, btw. In fact, software that cannot be used commercially is nonfree! There is no moral objection to a programmer being paid to write software. The objection is to software licensing that denies user of that software the "four freedoms".

https://www.gnu.org/philosophy/free-sw.html

Grants: http://en.wikipedia.org/wiki/Richard_Stallman#Honors_and_awa...

It's said he has some serious cash in the bank. Given his eccentric but modest lifestyle, I doubt he'll ever have financial problems.

I can sympathize with RMS's argument that companies like Apple & Google can create plugins and modules that are proprietary because LLVM/Clang has a non-copyleft license.

However, it would not be in any contributing companies favor to avoid pushing changes back up stream. The pool of people work together to solve really hard problems and they all need to be on the same page. Otherwise that work will become extremely hard to maintain when merges do need to happen.

Maybe I do not understand the licensing, but since LLVM is "more" free, couldn't RMS and his FSF members create a GPLv3 version of it that meets his goal?

> Maybe I do not understand the licensing, but since LLVM is "more" free, couldn't RMS and his FSF members create a GPLv3 version of it that meets his goal?

Yes, if you could get together a lot of people you could fork llvm under a different license -- GPL or proprietary. But forking to GPL would a) be a bit rude, and perhaps more importantly b) most likely just be a dead fork. You would have to contribute a fairly significant patch (I can't think of anything that would qualify at this stage of LLVM/Clang maturity) under GPL for "most" to want to use your version.

So, no, they can't practically do that, even if the license permits it.

And at any rate; c) Since the architecture of LLVM allows proprietary extensions, even if Clang/LLVM was under the GPL big changes would be needed to "force" the GPL on things like CUDA compilers etc.

(This is the point that ERS originally raised, arguably with limited knowledge of actual modern architecture of GCC, that GCC is artificially kept monolithic and by extension tied to a technically inferior architecture).